From c99b3618e8a13bdf0ea5defaab5be9d6b2bfe85c Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 23 Jun 2026 18:12:36 -0700 Subject: [PATCH 01/11] IxVM kernel: klimbs_pow via binary exponentiation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))`'s O(exp) per-step memo growth with a binary-exponentiation recursion of depth O(log exp). Both `exp / 2` and `exp % 2` route through the native `unconstrained_big_uint_div_mod` op, so each level pays O(1) for the division — `log2(exp)` memo entries for `klimbs_pow` itself + the `klimbs_mul(base, base)` doublings. `lake test -- --ignored ixvm` on `IxVMPrim.nat_pow_big` (`(2 ^ 16384 : Nat) - 2 ^ 16384 = 0`, measured against the current `ap/utf8-mod-witness` baseline): 3_941_276_885 → 71_856_587 FFT (-98.2%). Tests/Ix/IxVM.lean: * new `IxVMPrim.nat_pow_big` synthetic — exercises `klimbs_pow` at a non-trivial exponent (`2 ^ 16384`) so future regressions in the body shift its FFT pin. * small pin shifts in `nat_shl_lit`, `nat_shr_lit`, `nat_div_lit`, `nat_mod_lit`, `nat_gcd_lit`, `bv_to_nat_lit` — all reduce via `klimbs_pow` / `klimbs_div_mod` and absorb the new cost shape. --- Ix/IxVM/Kernel/Primitive.lean | 19 ++++++++++++++++++- Tests/Ix/IxVM.lean | 14 +++++++++++--- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/Ix/IxVM/Kernel/Primitive.lean b/Ix/IxVM/Kernel/Primitive.lean index 6462e3be..2254f08b 100644 --- a/Ix/IxVM/Kernel/Primitive.lean +++ b/Ix/IxVM/Kernel/Primitive.lean @@ -1152,10 +1152,27 @@ def primitive := ⟦ } } + -- Binary exponentiation. Replaces the old O(exp) recursive + -- `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))` body, which + -- created one per-fn memo row per exponent step and OOM'd for + -- non-trivial exponents. Recursion depth is `log2(exp)` — for + -- `exp = 2^32` that's 32 memo entries instead of 4 billion. + -- + -- Both `klimbs_div2` (= `klimbs_div(exp, 2)`) and `klimbs_is_odd` + -- (= `klimbs_mod(exp, 2) != 0`) route through `klimbs_div_mod`, which + -- is itself native (unconstrained_big_uint_div_mod) — so the + -- division per step is O(1) work. fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs { match klimbs_is_zero(exp) { 1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))), - 0 => klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp))), + 0 => + let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); + let (half, r) = klimbs_div_mod(exp, two); + let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half)); + match klimbs_is_zero(r) { + 1 => sq, + 0 => klimbs_mul(base, sq), + }, } } diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 41c7ac42..d73e870d 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -44,6 +44,13 @@ public theorem nat_lor_lit : Nat.lor 0xf0 0x0f = 0xff := rfl public theorem nat_xor_lit : Nat.xor 0xff 0x0f = 0xf0 := rfl public theorem nat_shl_lit : Nat.shiftLeft 1 8 = 256 := rfl public theorem nat_shr_lit : Nat.shiftRight 256 4 = 16 := rfl +-- Synthetic: exercises `klimbs_pow` at a non-trivial exponent so the cost +-- of the current O(exp) recursive implementation shows up in the FFT pin. +-- Sized to terminate under typical caps with the current O(exp) body — a +-- proxy for the eventual binary-exponentiation rewrite. +set_option exponentiation.threshold 65536 in +set_option maxRecDepth 65536 in +public theorem nat_pow_big : (2 ^ 16384 : Nat) - (2 ^ 16384) = 0 := rfl -- Nat predicates (return Bool ctors) public theorem nat_beq_lit : Nat.beq 42 42 = true := rfl @@ -141,15 +148,16 @@ private def kernelCheckEntries : List (String × Nat) := [ ("IxVMPrim.nat_land_lit", 1_019_743_752), ("IxVMPrim.nat_lor_lit", 1_020_972_680), ("IxVMPrim.nat_xor_lit", 1_029_804_417), - ("IxVMPrim.nat_shl_lit", 34_843_370), - ("IxVMPrim.nat_shr_lit", 372_727_841), + ("IxVMPrim.nat_shl_lit", 34_836_668), + ("IxVMPrim.nat_shr_lit", 372_729_464), + ("IxVMPrim.nat_pow_big", 71_856_587), ("IxVMPrim.nat_beq_lit", 24_108_404), ("IxVMPrim.nat_ble_lit", 22_469_243), ("IxVMPrim.nat_dec_le", 198_104_580), ("IxVMPrim.nat_dec_lt", 202_076_479), ("IxVMPrim.nat_dec_eq", 82_352_518), ("IxVMPrim.str_size_lit", 733_902_817), - ("IxVMPrim.bv_to_nat_lit", 577_368_692), + ("IxVMPrim.bv_to_nat_lit", 577_322_203), -- Mutual block + multi-member recursors ("IxVMInd.Even", 25_965_406), ("IxVMInd.Odd", 25_728_543), From 27fc940bb8b6f533141151bbc81b4553abd76e06 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 24 Jun 2026 10:32:23 -0700 Subject: [PATCH 02/11] IxVM kernel: augment addr_pos_map with blob-ref sentinels MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `lookup_addr_pos`'s rbtree (`addr_pos_map`) only contained const addresses. Every blob ref (literal-blob payload pointers in `Constant.refs`) probed the map, missed, and fell through to the O(N) linear scan over `all_addrs` which also returned 0. Wasted work proportional to (blob refs × shard closure size). Add a third value class to the same rbtree: the sentinel `4294967295` (beyond any honest `pos+1`), inserted by walking each const's `refs` once via `augment_with_blob_refs`. Any ref not already mapped to a const-position gets the sentinel. `lookup_addr_pos` becomes a 3-way match: `0` → fall back to linear scan (now only fires under the de-intern soundness corner-case, ~never in practice); `SENTINEL` → return 0 directly (known blob); `pos+1` → return `pos`. `is_blob` mirrors the same match. Soundness preserved: every probe still relies on the positive direction `ptr_val` equality ⇒ content equality (Aiur Store's content-addressing invariant). The linear fallback stays put for the (still theoretical) malicious de-intern, where it uses content-based `address_eq`. `lake exe ix check --ixe init.ixe --ixes init.ixes --shard 51` (`ulimit -v 23000000`, with the kernel's blake3 paths in `load_verified_constant` / `load_verified_blob` / `load_verified_claim` stubbed for profiling): 119_152_044_062 → 102_190_540_489 FFT (-14.2%). Tests/Ix/IxVM.lean: 42 pin shifts absorbing the per-ingress augment-walk overhead. --- Ix/IxVM/Ingress.lean | 74 ++++++++++++++++++++++++++++++++++---- Tests/Ix/IxVM.lean | 84 ++++++++++++++++++++++---------------------- 2 files changed, 109 insertions(+), 49 deletions(-) diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean index 5fee5918..56987ed7 100644 --- a/Ix/IxVM/Ingress.lean +++ b/Ix/IxVM/Ingress.lean @@ -137,16 +137,16 @@ def ingress := ⟦ } } - -- Check if an address is a blob: it's a blob iff it's NOT a constant, - -- i.e. absent from `addr_pos_map` (which is keyed by every constant - -- address — see `build_addr_pos_map`). Membership only; the stored - -- position value (pos+1 ≥ 1) is irrelevant here, only "present vs 0". - -- Blob addresses and constant addresses are different by design - -- (different hash preimage structures). O(log N) tree lookup. + -- Check if an address is a blob via the augmented `addr_pos_map`: + -- value == 0 (absent) → conservatively blob (the historical semantics; + -- sound because a content-bound blob load downstream re-verifies); + -- value == 4294967295 (SENTINEL) → known blob ref; + -- value > 0 and < SENTINEL (pos+1) → known const. fn is_blob(addr: Addr, addr_pos_map: &RBTreeMap‹G›) -> G { let hit = rbtree_map_lookup_or_default(ptr_val(addr), load(addr_pos_map), 0); match hit { 0 => 1, + 4294967295 => 1, _ => 0, } } @@ -227,11 +227,27 @@ def ingress := ⟦ -- fall back to the content-based `address_eq` scan, which returns 0 when -- truly absent. Honest provers always intern, so the fallback adds ~0 -- rows to the honest trace; the hot path is the O(log N) tree lookup. + -- Single-map ptr_val lookup. After `build_addr_pos_map_aug`, the map + -- carries three classes of value for an address key: + -- * 0 → not registered (truly unknown OR de-interned const) + -- * SENTINEL → known blob ref (= 4294967295, beyond any honest pos+1) + -- * pos+1 → known const at position `pos` + -- The blob class is populated once per ingress by walking every + -- constant's `refs` and inserting any non-const ref with SENTINEL. + -- Blob-ref lookups (the dominant non-const-ref traffic) now hit the + -- O(log N) probe and short-circuit to 0 without scanning. + -- + -- ptr_val-key soundness: ptr equality → content equality (positive + -- direction, sound because Aiur's Store content-addresses by content). + -- Hit on either pos+1 or SENTINEL is sound by ptr equality. Miss falls + -- through to the content-based linear scan, which catches any + -- de-interned const at its true position. fn lookup_addr_pos(target: Addr, addr_pos_map: &RBTreeMap‹G›, all_addrs: List‹Addr›, pos_map: List‹G›) -> G { let hit = rbtree_map_lookup_or_default(ptr_val(target), load(addr_pos_map), 0); match hit { 0 => lookup_addr_pos_linear(target, all_addrs, pos_map), + 4294967295 => 0, _ => hit - 1, } } @@ -285,6 +301,45 @@ def ingress := ⟦ } } + -- Walk all constants' `refs`. For every ref whose ptr_val is NOT + -- already mapped to a const-position (= a true const-ref), insert it + -- with the BLOB sentinel `4294967295`. Result: every ref a const + -- carries is classified at build time; `lookup_addr_pos` short-circuits + -- O(N) linear scans on blob refs to O(log N) probes. + -- + -- Duplicate refs across consts hit the existing entry on subsequent + -- inserts; the probe-before-insert prevents overwriting a const's + -- pos+1 entry. The walk is O(R log N) where R = total refs in the + -- shard's closure, N = #consts + #unique-blob-refs. + fn augment_with_blob_refs(consts: List‹&Constant›, m: RBTreeMap‹G›) -> RBTreeMap‹G› { + match load(consts) { + ListNode.Nil => m, + ListNode.Cons(&c, rest) => + match c { + Constant.Mk(_, _, refs, _) => + let m1 = insert_refs_as_blobs(refs, m); + augment_with_blob_refs(rest, m1), + }, + } + } + + fn insert_refs_as_blobs(refs: List‹Addr›, m: RBTreeMap‹G›) -> RBTreeMap‹G› { + match load(refs) { + ListNode.Nil => m, + ListNode.Cons(addr, rest) => + let key = ptr_val(addr); + let hit = rbtree_map_lookup_or_default(key, m, 0); + match hit { + 0 => + -- Not yet registered: classify as blob ref via SENTINEL. + insert_refs_as_blobs(rest, rbtree_map_insert(key, 4294967295, m)), + _ => + -- Already a const (pos+1) or already a blob (SENTINEL): leave alone. + insert_refs_as_blobs(rest, m), + }, + } + } + -- Find the start position of a block by its block address. fn lookup_block_start(target: Addr, block_addrs: List‹Addr›, block_starts: List‹G›) -> G { match load(block_addrs) { @@ -1034,7 +1089,12 @@ def ingress := ⟦ pos: G ) -> List‹&ConvertInput› { -- Built once here; threaded as the fast-path index for `lookup_addr_pos`. - let addr_pos_map = store(build_addr_pos_map(all_addrs, pos_map)); + -- The base map carries `pos+1` for each const; `augment_with_blob_refs` + -- then walks every const's `refs` and tags every previously-unregistered + -- ref with the BLOB sentinel (4294967295), so blob-ref lookups + -- short-circuit instead of falling through to the O(N) linear scan. + let base_map = build_addr_pos_map(all_addrs, pos_map); + let addr_pos_map = store(augment_with_blob_refs(consts, base_map)); build_convert_inputs_walk(consts, cur_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, store(ListNode.Nil)) diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index d73e870d..45ae64e1 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -122,53 +122,53 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_715_513), - ("HEq.rec", 2_681_137), - ("Eq.rec", 2_575_090), - ("Nat", 1_857_572), - ("Nat.add", 12_973_039), - ("Nat.add_comm", 54_350_110), - ("Nat.decEq", 68_538_632), - ("Nat.decLe", 191_354_793), - ("Nat.sub_le_of_le_add", 515_056_158), + ("HEq", 1_715_966), + ("HEq.rec", 2_682_331), + ("Eq.rec", 2_576_284), + ("Nat", 1_858_025), + ("Nat.add", 12_983_943), + ("Nat.add_comm", 54_330_980), + ("Nat.decEq", 68_594_289), + ("Nat.decLe", 191_364_012), + ("Nat.sub_le_of_le_add", 515_130_560), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_863_374), - ("Array.append_assoc", 2_588_157_538), - ("Vector.append", 2_661_244_845), + ("Trans.mk", 2_864_146), + ("Array.append_assoc", 2_566_382_883), + ("Vector.append", 2_638_552_021), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 28_083_713), - ("IxVMPrim.nat_sub_lit", 33_755_207), - ("IxVMPrim.nat_mul_lit", 24_642_249), - ("IxVMPrim.nat_mul_big", 24_116_975), - ("IxVMPrim.nat_div_lit", 367_262_842), - ("IxVMPrim.nat_mod_lit", 375_958_840), - ("IxVMPrim.nat_succ_lit", 7_307_039), - ("IxVMPrim.nat_pred_lit", 14_682_236), - ("IxVMPrim.nat_gcd_lit", 605_514_332), - ("IxVMPrim.nat_land_lit", 1_019_743_752), - ("IxVMPrim.nat_lor_lit", 1_020_972_680), - ("IxVMPrim.nat_xor_lit", 1_029_804_417), - ("IxVMPrim.nat_shl_lit", 34_836_668), - ("IxVMPrim.nat_shr_lit", 372_729_464), - ("IxVMPrim.nat_pow_big", 71_856_587), - ("IxVMPrim.nat_beq_lit", 24_108_404), - ("IxVMPrim.nat_ble_lit", 22_469_243), - ("IxVMPrim.nat_dec_le", 198_104_580), - ("IxVMPrim.nat_dec_lt", 202_076_479), - ("IxVMPrim.nat_dec_eq", 82_352_518), - ("IxVMPrim.str_size_lit", 733_902_817), - ("IxVMPrim.bv_to_nat_lit", 577_322_203), + ("IxVMPrim.nat_add_lit", 28_082_349), + ("IxVMPrim.nat_sub_lit", 33_722_451), + ("IxVMPrim.nat_mul_lit", 24_644_737), + ("IxVMPrim.nat_mul_big", 24_146_724), + ("IxVMPrim.nat_div_lit", 366_893_945), + ("IxVMPrim.nat_mod_lit", 375_602_678), + ("IxVMPrim.nat_succ_lit", 7_314_408), + ("IxVMPrim.nat_pred_lit", 14_706_095), + ("IxVMPrim.nat_gcd_lit", 605_222_820), + ("IxVMPrim.nat_land_lit", 1_019_495_718), + ("IxVMPrim.nat_lor_lit", 1_020_299_077), + ("IxVMPrim.nat_xor_lit", 1_029_101_731), + ("IxVMPrim.nat_shl_lit", 34_802_946), + ("IxVMPrim.nat_shr_lit", 372_209_350), + ("IxVMPrim.nat_pow_big", 71_850_166), + ("IxVMPrim.nat_beq_lit", 24_145_604), + ("IxVMPrim.nat_ble_lit", 22_475_134), + ("IxVMPrim.nat_dec_le", 198_007_550), + ("IxVMPrim.nat_dec_lt", 201_972_221), + ("IxVMPrim.nat_dec_eq", 82_417_673), + ("IxVMPrim.str_size_lit", 726_987_300), + ("IxVMPrim.bv_to_nat_lit", 576_925_093), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_965_406), - ("IxVMInd.Odd", 25_728_543), - ("IxVMInd.Even.rec", 31_629_158), - ("IxVMInd.Odd.rec", 31_628_265), + ("IxVMInd.Even", 25_974_275), + ("IxVMInd.Odd", 25_737_413), + ("IxVMInd.Even.rec", 31_628_577), + ("IxVMInd.Odd.rec", 31_627_681), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_634_462), - ("IxVMInd.Tree.rec", 4_870_642), + ("IxVMInd.Tree", 2_635_546), + ("IxVMInd.Tree.rec", 4_874_311), -- Edge cases from prelude - ("String.Internal.append", 725_415_461), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_091_354_031), + ("String.Internal.append", 718_452_811), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_081_131_375), ] private def nameOfString (str : String) : Lean.Name := From 696ee2b01ee6b93ff7fbe16e77fa86e311872928 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Sat, 27 Jun 2026 11:06:32 -0700 Subject: [PATCH 03/11] =?UTF-8?q?IxVM=20ingress:=20plumbing=20helpers=20+?= =?UTF-8?q?=20sidecar=E2=86=92rbtree=20migrations=20+=20ptr-passing?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A consolidated refactor of the ingress pipeline guided by a 5-reviewer synthesis of accidental complexity sites. Three families of change: PLUMBING * `Blake3.lean`: `verify_bytes_against(bytes, expected)` + `bytes_to_addr(bytes)` + `blake3_flat(input)` centralise the 24-line `[h[i][j]]` digest reshape that was hand-unrolled at 7 sites. ~100 lines of boilerplate deleted. * `Ingress.lean`: `load_payload_const`/`blob`/`hint` + `ch_const`/`blob`/`hint` factor the `io_get_info` + `#read_byte_stream` boilerplate at 6 sites. `load_verified_blob` no longer double-`load(addr)`s. * `sentinel_blob_ref()` named const replaces one bare `4294967295`. SIDECAR LISTS → RBTREE * `lookup_canon_addr`: O(N) parallel-list walk → O(log N) rbtree probe via new `build_canon_addr_map`. `canon_addrs: List` arg replaced by `canon_addr_map: &RBTreeMap` (one threaded ptr). * `lookup_block_start`: O(N) parallel-list walk → O(log N) rbtree probe via new `build_block_start_map`. `block_addrs` / `block_starts` args replaced by `block_start_map: &RBTreeMap` across ~12 fn signatures. * `build_aux_recr_ctor_idxs` returns `(idxs, block_addr)` so the standalone-Recr caller in `build_convert_inputs_walk` doesn't redo the `rec_typ_to_inductive_addr` + `load_verified_constant` chain to recover `block_addr` — `build_aux_recr_ctor_idxs` already computed it internally. * `build_ref_idxs_and_blobs` fuses the two separate walks (`build_ref_idxs_mapped` + `build_lit_blobs`) into one — single rbtree probe per ref produces both `ref_idxs` and `lit_blobs`. 5 caller sites simplified. PTR-PASSING (per `reference_aiur_pass_pointer_not_value`) * `convert_univ(u: &Univ)`: per-row input width drops from 5-variant union to one G column. Caller `convert_univ_idxs` already produces the `&Univ` via `list_lookup(univs, idx)` — no extra `store`. * `convert_one(input: &ConvertInput)`: caller `convert_all` already has `&input` from the `ListNode.Cons` destructure. DEAD CODE DELETED `address_in_list`, `apply_ctor_overrides`, `lookup_override`, `build_lit_blobs`, `build_ref_idxs_mapped`, `is_blob`, `ctx_convert_expr` — all unused after the migrations above. TRIED + REVERTED (left as notes in code where instructive): * Fused `build_addr_pos_map` + `augment_with_blob_refs` single-pass. Lost to Aiur's per-row width tax — two narrower passes cheaper than one merged wide pass. * `convert_expr(ctx: &ConvertCtx)` ptr. Per-arm `load(ctx)` cost > raw-arg threading. * `compute_layout_walk` seen-mptrs/seen-poses → rbtree. Small regression on typical shards (few enough Muts blocks that O(N) list scan is already cheap; rbtree value column tax > savings). * `block_members_map` to skip per-projection `load_verified_constant`. Lost because Aiur memoises `load_verified_constant` automatically — the new rbtree probe's width tax exceeded the savings from the eliminated match cascade. * `ctx` everywhere as `&ConvertCtx` (with `store(...)` at 5 construction sites). The added `store` rows offset the per-row savings — wash. `lake test -- --ignored ixvm`: 42 pin shifts, all measurable wins vs the `ap/blob-ref-rbtree-augment` tip. Cumulative on heavy consts: * `Nat.add_comm`: 54_369_745 → 54_049_773 FFT (-0.59%) * `Nat.sub_le_of_le_add`: 515_331_420 → 510_843_459 FFT (-0.87%) * `Array.append_assoc`: 2_567_087_893 → 2_537_360_311 FFT (-1.16%) * `Vector.append`: 2_639_286_078 → 2_607_800_745 FFT (-1.19%) * `String.Internal.append`: 718_803_075 → 708_296_270 FFT (-1.46%) * `IxVMInd.Even.rec`: 31_659_493 → 31_434_525 FFT (-0.71%) * `_private....extractMainModule._unsafe_rec`: 1_081_617_705 → 1_064_689_765 FFT (-1.57%) --- Ix/IxVM/Blake3.lean | 29 +++ Ix/IxVM/Convert.lean | 156 +++++++------ Ix/IxVM/Ingress.lean | 455 ++++++++++++++++---------------------- Ix/IxVM/Kernel/Claim.lean | 57 +---- Tests/Ix/IxVM.lean | 84 +++---- 5 files changed, 360 insertions(+), 421 deletions(-) diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean index 7412c6e4..fa06ded8 100644 --- a/Ix/IxVM/Blake3.lean +++ b/Ix/IxVM/Blake3.lean @@ -45,6 +45,35 @@ def blake3 := ⟦ blake3_compress_layer(load(blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store([0u8; 8]), store(IV), store(Layer.Nil)))) } + -- Flatten blake3's [[U8;4];8] output into the [U8;32] form every caller wants. + fn blake3_flat(input: ByteStream) -> [U8; 32] { + let h = blake3(input); + [h[0][0], h[0][1], h[0][2], h[0][3], + h[1][0], h[1][1], h[1][2], h[1][3], + h[2][0], h[2][1], h[2][2], h[2][3], + h[3][0], h[3][1], h[3][2], h[3][3], + h[4][0], h[4][1], h[4][2], h[4][3], + h[5][0], h[5][1], h[5][2], h[5][3], + h[6][0], h[6][1], h[6][2], h[6][3], + h[7][0], h[7][1], h[7][2], h[7][3]] + } + + -- Hash `bytes` and assert the digest equals `expected`. Used by every + -- IOBuffer-load path that verifies the pre-image of a content-addressed + -- pointer matches the bytes the prover supplied. + fn verify_bytes_against(bytes: ByteStream, expected: [U8; 32]) { + assert_eq!(blake3_flat(bytes), expected); + () + } + + -- Hash `bytes` and intern the digest into the Store. Returned pointer is + -- the canonical content-addressed `Addr` shape (`&[U8;32]`). Used by every + -- site that synthesises an address from raw bytes (e.g. `expr_addr`, + -- `leaf_hash`, `node_hash`, `cprj_content_addr`). + fn bytes_to_addr(bytes: ByteStream) -> &[U8; 32] { + store(blake3_flat(bytes)) + } + fn blake3_next_layer(layer: Layer, digest: [[U8; 4]; 8], root: G) -> (MaybeDigest, Layer) { match layer { Layer.Nil => (MaybeDigest.Some(digest), Layer.Nil), diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean index b9cbd972..881ee9f2 100644 --- a/Ix/IxVM/Convert.lean +++ b/Ix/IxVM/Convert.lean @@ -53,12 +53,16 @@ def convert := ⟦ -- Universe conversion: Ixon Univ -> KLevel -- ============================================================================ - fn convert_univ(u: Univ) -> KLevel { - match u { + -- Take `&Univ` (pointer) to shrink the per-row input width — Univ is a + -- 5-variant enum, by-value passing taxes every row with the widest + -- arm's columns. Mirror the `reference_aiur_pass_pointer_not_value` + -- pattern already used for `convert_expr(e: &Expr)`. + fn convert_univ(u: &Univ) -> KLevel { + match load(u) { Univ.Zero => KLevel.Zero, - Univ.Succ(&inner) => KLevel.Succ(store(convert_univ(inner))), - Univ.Max(&a, &b) => KLevel.Max(store(convert_univ(a)), store(convert_univ(b))), - Univ.IMax(&a, &b) => KLevel.IMax(store(convert_univ(a)), store(convert_univ(b))), + Univ.Succ(inner) => KLevel.Succ(store(convert_univ(inner))), + Univ.Max(a, b) => KLevel.Max(store(convert_univ(a)), store(convert_univ(b))), + Univ.IMax(a, b) => KLevel.IMax(store(convert_univ(a)), store(convert_univ(b))), Univ.Var(idx) => KLevel.Param(flatten_u64(idx)), } } @@ -70,8 +74,8 @@ def convert := ⟦ ListNode.Cons(idx, rest) => -- universe indices are small; walk with a field index (cheap per-step -- field sub) instead of `list_lookup_u64`'s per-step U64 predecessor. - let u = load(list_lookup(univs, flatten_u64(idx))); - store(ListNode.Cons(store(convert_univ(u)), convert_univ_idxs(rest, univs))), + let u_ref = list_lookup(univs, flatten_u64(idx)); + store(ListNode.Cons(store(convert_univ(u_ref)), convert_univ_idxs(rest, univs))), } } @@ -149,8 +153,8 @@ def convert := ⟦ Expr.Srt(univ_idx) => -- field-indexed walk (see `convert_univ_idxs`): avoids the per-step -- U64 predecessor of `list_lookup_u64` on this hot universe lookup. - let u = load(list_lookup(univs, flatten_u64(univ_idx))); - store(KExprNode.Srt(store(convert_univ(u)))), + let u_ref = list_lookup(univs, flatten_u64(univ_idx)); + store(KExprNode.Srt(store(convert_univ(u_ref)))), Expr.Var(idx) => store(KExprNode.BVar(flatten_u64(idx))), @@ -208,13 +212,6 @@ def convert := ⟦ } } - fn ctx_convert_expr(e: &Expr, ctx: ConvertCtx) -> KExpr { - match ctx { - ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => - convert_expr(e, sharing, ref_idxs, recur_idxs, lit_blobs, univs), - } - } - -- ============================================================================ -- Recursor rule conversion -- ============================================================================ @@ -233,11 +230,14 @@ def convert := ⟦ RecursorRule.Mk(nfields, rhs) => match load(rule_ctor_idxs) { ListNode.Cons(ctor_idx, rest_ctor_idxs) => - let krhs = ctx_convert_expr(rhs, ctx); - let krule = KRecRule.Mk(ctor_idx, flatten_u64(nfields), krhs); - store(ListNode.Cons( - krule, - convert_rules(rest_rules, rest_ctor_idxs, ctx))), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + let krhs = convert_expr(rhs, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let krule = KRecRule.Mk(ctor_idx, flatten_u64(nfields), krhs); + store(ListNode.Cons( + krule, + convert_rules(rest_rules, rest_ctor_idxs, ctx))), + }, }, }, } @@ -248,73 +248,91 @@ def convert := ⟦ -- ============================================================================ fn convert_definition(d: Definition, ctx: ConvertCtx, hint: G) -> KConstantInfo { - match d { - Definition.Mk(kind, safety, lvls, typ, value) => - let ktyp = ctx_convert_expr(typ, ctx); - let kval = ctx_convert_expr(value, ctx); - match kind { - DefKind.Definition => - KConstantInfo.Defn(flatten_u64(lvls), ktyp, kval, safety, hint), - DefKind.Opaque => - match safety { - DefinitionSafety.Unsafe => - KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 1), - _ => - KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 0), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match d { + Definition.Mk(kind, safety, lvls, typ, value) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let kval = convert_expr(value, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + match kind { + DefKind.Definition => + KConstantInfo.Defn(flatten_u64(lvls), ktyp, kval, safety, hint), + DefKind.Opaque => + match safety { + DefinitionSafety.Unsafe => + KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 1), + _ => + KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 0), + }, + DefKind.Theorem => + KConstantInfo.Thm(flatten_u64(lvls), ktyp, kval), }, - DefKind.Theorem => - KConstantInfo.Thm(flatten_u64(lvls), ktyp, kval), }, } } fn convert_axiom(a: Axiom, ctx: ConvertCtx) -> KConstantInfo { - match a { - Axiom.Mk(is_unsafe, lvls, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match a { + Axiom.Mk(is_unsafe, lvls, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe), + }, } } fn convert_quotient(q: Quotient, ctx: ConvertCtx) -> KConstantInfo { - match q { - Quotient.Mk(kind, lvls, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match q { + Quotient.Mk(kind, lvls, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind), + }, } } fn convert_recursor(r: Recursor, ctx: ConvertCtx, rule_ctor_idxs: List‹G›, block_addr: Addr) -> KConstantInfo { - match r { - Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) => - let ktyp = ctx_convert_expr(typ, ctx); - let krules = convert_rules(rules, rule_ctor_idxs, ctx); - KConstantInfo.Rec( - flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), - flatten_u64(motives), flatten_u64(minors), - krules, k, is_unsafe, block_addr), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match r { + Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let krules = convert_rules(rules, rule_ctor_idxs, ctx); + KConstantInfo.Rec( + flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), + flatten_u64(motives), flatten_u64(minors), + krules, k, is_unsafe, block_addr), + }, } } fn convert_inductive(ind: Inductive, ctx: ConvertCtx, ctor_idxs: List‹G›, block_addr: Addr) -> KConstantInfo { - match ind { - Inductive.Mk(is_rec, is_refl, is_unsafe, lvls, params, indices, nested, typ, _) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Induct( - flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), - ctor_idxs, is_rec, is_refl, is_unsafe, flatten_u64(nested), block_addr), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match ind { + Inductive.Mk(is_rec, is_refl, is_unsafe, lvls, params, indices, nested, typ, _) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Induct( + flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), + ctor_idxs, is_rec, is_refl, is_unsafe, flatten_u64(nested), block_addr), + }, } } fn convert_constructor(c: Constructor, ctx: ConvertCtx, induct_idx: G) -> KConstantInfo { - match c { - Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Ctor( - flatten_u64(lvls), ktyp, induct_idx, flatten_u64(cidx), - flatten_u64(params), flatten_u64(fields), is_unsafe), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match c { + Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Ctor( + flatten_u64(lvls), ktyp, induct_idx, flatten_u64(cidx), + flatten_u64(params), flatten_u64(fields), is_unsafe), + }, } } @@ -322,9 +340,11 @@ def convert := ⟦ -- Top-level conversion -- ============================================================================ - -- Convert a single resolved input to a KConstantInfo - fn convert_one(input: ConvertInput) -> KConstantInfo { - match input { + -- Convert a single resolved input to a KConstantInfo. Takes &ConvertInput + -- (pointer) so the per-row input width is one G column, not the full + -- ConvertInput union width. + fn convert_one(input: &ConvertInput) -> KConstantInfo { + match load(input) { ConvertInput.Mk(ctx, kind) => match kind { ConvertKind.CKDefn(d, hint) => convert_definition(d, ctx, hint), @@ -342,7 +362,7 @@ def convert := ⟦ fn convert_all(inputs: List‹&ConvertInput›) -> List‹&KConstantInfo› { match load(inputs) { ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(&input, rest) => + ListNode.Cons(input, rest) => let ci = convert_one(input); store(ListNode.Cons(store(ci), convert_all(rest))), } diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean index 56987ed7..32854a8a 100644 --- a/Ix/IxVM/Ingress.lean +++ b/Ix/IxVM/Ingress.lean @@ -7,25 +7,33 @@ public section namespace IxVM def ingress := ⟦ + -- IOBuffer channel identifiers. See `ClaimHarness.lean` for the host-side + -- counterpart that seeds these channels. + fn ch_const() -> G { 0 } + fn ch_blob() -> G { 1 } + fn ch_hint() -> G { 2 } + + -- Read the raw bytes the prover seeded at `key` on `channel`. + -- Channels and keys are documented per call site; the helper exists + -- only to centralise the `io_get_info` + `#read_byte_stream` pair. + fn load_payload_const(key: [U8; 32]) -> ByteStream { + let (idx, len) = io_get_info(0, key); + #read_byte_stream(0, idx, len) + } + fn load_payload_blob(key: [U8; 32]) -> ByteStream { + let (idx, len) = io_get_info(1, key); + #read_byte_stream(1, idx, len) + } + fn load_payload_hint(key: [U8; 32]) -> ByteStream { + let (idx, len) = io_get_info(2, key); + #read_byte_stream(2, idx, len) + } + -- Load a constant from IOBuffer by address, verify blake3, deserialize. fn load_verified_constant(addr: Addr) -> Constant { let raw = load(addr); - let (idx, len) = io_get_info(0, raw); - let bytes = #read_byte_stream(0, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - raw - ); + let bytes = load_payload_const(raw); + let _ = verify_bytes_against(bytes, raw); let (constant, rest) = get_constant(bytes); assert_eq!(load(rest), ListNode.Nil); constant @@ -34,22 +42,9 @@ def ingress := ⟦ -- Load a blob from IOBuffer by address, verify blake3, return raw bytes. -- Blobs live on channel 1; constants live on channel 0 with the same key. fn load_verified_blob(addr: Addr) -> ByteStream { - let (idx, len) = io_get_info(1, load(addr)); - let bytes = #read_byte_stream(1, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - load(addr) - ); + let raw = load(addr); + let bytes = load_payload_blob(raw); + let _ = verify_bytes_against(bytes, raw); bytes } @@ -112,44 +107,16 @@ def ingress := ⟦ -- Caller MUST only invoke this for Defn addrs; the harness only seeds -- channel 2 for defns. A missing key aborts execution (correct). fn load_constant_hint(addr: Addr) -> G { - let (idx, len) = io_get_info(2, load(addr)); - let bytes = #read_byte_stream(2, idx, len); + let bytes = load_payload_hint(load(addr)); match load(bytes) { ListNode.Cons(b, _) => to_field(b), } } - -- Build lit_blobs by loading and verifying each blob on demand. - -- A ref is a blob if it's not in all_addrs (the constant address list). - -- For constant refs, returns an empty ByteStream (never read by conversion). - fn build_lit_blobs(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›) -> List‹ByteStream› { - match load(refs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(addr, rest) => - let blob = is_blob(addr, addr_pos_map); - match blob { - 1 => - let bs = load_verified_blob(addr); - store(ListNode.Cons(bs, build_lit_blobs(rest, addr_pos_map))), - 0 => - store(ListNode.Cons(store(ListNode.Nil), build_lit_blobs(rest, addr_pos_map))), - }, - } - } - - -- Check if an address is a blob via the augmented `addr_pos_map`: - -- value == 0 (absent) → conservatively blob (the historical semantics; - -- sound because a content-bound blob load downstream re-verifies); - -- value == 4294967295 (SENTINEL) → known blob ref; - -- value > 0 and < SENTINEL (pos+1) → known const. - fn is_blob(addr: Addr, addr_pos_map: &RBTreeMap‹G›) -> G { - let hit = rbtree_map_lookup_or_default(ptr_val(addr), load(addr_pos_map), 0); - match hit { - 0 => 1, - 4294967295 => 1, - _ => 0, - } - } + -- Sentinel value stored in `addr_pos_map` for addresses known to be + -- blob refs (not constants). Beyond any honest `pos+1` so it cannot + -- collide with a real const-position encoding. + fn sentinel_blob_ref() -> G { 4294967295 } -- Extract the Muts block address from a projection ConstantInfo. -- Returns [0; 32] for non-projection constants. @@ -301,7 +268,7 @@ def ingress := ⟦ } } - -- Walk all constants' `refs`. For every ref whose ptr_val is NOT +-- Walk all constants' `refs`. For every ref whose ptr_val is NOT -- already mapped to a const-position (= a true const-ref), insert it -- with the BLOB sentinel `4294967295`. Result: every ref a const -- carries is classified at build time; `lookup_addr_pos` short-circuits @@ -332,7 +299,7 @@ def ingress := ⟦ match hit { 0 => -- Not yet registered: classify as blob ref via SENTINEL. - insert_refs_as_blobs(rest, rbtree_map_insert(key, 4294967295, m)), + insert_refs_as_blobs(rest, rbtree_map_insert(key, sentinel_blob_ref(), m)), _ => -- Already a const (pos+1) or already a blob (SENTINEL): leave alone. insert_refs_as_blobs(rest, m), @@ -340,22 +307,32 @@ def ingress := ⟦ } } - -- Find the start position of a block by its block address. - fn lookup_block_start(target: Addr, block_addrs: List‹Addr›, block_starts: List‹G›) -> G { +-- Index `block_addrs`/`block_starts` into a single ptr_val-keyed rbtree so + -- the per-call lookup is O(log N) instead of an O(N) parallel-list walk. + -- ptr_val keying is sound by Aiur Store content-addressing. + fn build_block_start_map(block_addrs: List‹Addr›, block_starts: List‹G›) -> RBTreeMap‹G› { + build_block_start_map_walk(block_addrs, block_starts, RBTreeMap.Nil) + } + + fn build_block_start_map_walk(block_addrs: List‹Addr›, block_starts: List‹G›, + acc: RBTreeMap‹G›) -> RBTreeMap‹G› { match load(block_addrs) { - ListNode.Nil => 0, + ListNode.Nil => acc, ListNode.Cons(addr, rest_addrs) => match load(block_starts) { ListNode.Cons(start, rest_starts) => - let eq = address_eq(target, addr); - match eq { - 1 => start, - 0 => lookup_block_start(target, rest_addrs, rest_starts), - }, + build_block_start_map_walk(rest_addrs, rest_starts, + rbtree_map_insert(ptr_val(addr), start, acc)), }, } } + -- O(log N) block-start probe. Returns 0 when the address isn't a known + -- block (mirrors the historical "not found → 0" semantics). + fn lookup_block_start(target: Addr, block_start_map: &RBTreeMap‹G›) -> G { + rbtree_map_lookup_or_default(ptr_val(target), load(block_start_map), 0) + } + -- ============================================================================ -- Layout pass: compute block start positions and total kernel size -- ============================================================================ @@ -522,19 +499,17 @@ def ingress := ⟦ fn build_pos_map( consts: List‹&Constant›, addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, pos: G ) -> List‹G› { - build_pos_map_walk(consts, addrs, block_addrs, block_starts, pos, + build_pos_map_walk(consts, addrs, block_start_map, pos, store(ListNode.Nil), store(ListNode.Nil)) } fn build_pos_map_walk( consts: List‹&Constant›, addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, pos: G, seen_mptrs: List‹G›, seen_poses: List‹G› @@ -557,7 +532,7 @@ def ingress := ⟦ 1 => let first_pos = first_pos_for_mptr(mptr, seen_mptrs, seen_poses); store(ListNode.Cons(first_pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), 0 => let size = block_kernel_size(members); let new_seen_m = match mptr { @@ -569,12 +544,12 @@ def ingress := ⟦ _ => store(ListNode.Cons(pos, seen_poses)), }; store(ListNode.Cons(pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos + size, new_seen_m, new_seen_p))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + size, new_seen_m, new_seen_p))), }, ConstantInfo.IPrj(prj) => match prj { InductiveProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -582,14 +557,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.CPrj(prj) => match prj { ConstructorProj.Mk(idx, cidx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -597,14 +572,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let mem_off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + mem_off + 1 + flatten_u64(cidx), - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.RPrj(prj) => match prj { RecursorProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -612,14 +587,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.DPrj(prj) => match prj { DefinitionProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -627,13 +602,13 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, _ => store(ListNode.Cons(pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos + 1, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + 1, seen_mptrs, seen_poses))), }, }, }, @@ -644,13 +619,35 @@ def ingress := ⟦ -- Ref index building using position map -- ============================================================================ - fn build_ref_idxs_mapped(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, - all_addrs: List‹Addr›, pos_map: List‹G›) -> List‹G› { + -- Fused walk of `refs` producing both `ref_idxs` and `lit_blobs` in one + -- pass. Each ref goes through ONE rbtree probe (`addr_pos_map`) and the + -- result is interpreted as both classifications: + -- * hit == 0 (absent — de-intern soundness floor): fall back to linear + -- scan for `ref_idx`, leave `lit_blob` empty (the conservative path). + -- * hit == SENTINEL_BLOB_REF: known blob → load + decode; idx = 0. + -- * hit == pos + 1: known const → idx = pos, blob slot empty. + fn build_ref_idxs_and_blobs(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, + all_addrs: List‹Addr›, pos_map: List‹G›) + -> (List‹G›, List‹ByteStream›) { match load(refs) { - ListNode.Nil => store(ListNode.Nil), + ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)), ListNode.Cons(addr, rest) => - let pos = lookup_addr_pos(addr, addr_pos_map, all_addrs, pos_map); - store(ListNode.Cons(pos, build_ref_idxs_mapped(rest, addr_pos_map, all_addrs, pos_map))), + let (rest_idxs, rest_blobs) = + build_ref_idxs_and_blobs(rest, addr_pos_map, all_addrs, pos_map); + let hit = rbtree_map_lookup_or_default(ptr_val(addr), load(addr_pos_map), 0); + match hit { + 0 => + let pos = lookup_addr_pos_linear(addr, all_addrs, pos_map); + (store(ListNode.Cons(pos, rest_idxs)), + store(ListNode.Cons(store(ListNode.Nil), rest_blobs))), + 4294967295 => + let bs = load_verified_blob(addr); + (store(ListNode.Cons(0, rest_idxs)), + store(ListNode.Cons(bs, rest_blobs))), + _ => + (store(ListNode.Cons(hit - 1, rest_idxs)), + store(ListNode.Cons(store(ListNode.Nil), rest_blobs))), + }, } } @@ -751,49 +748,51 @@ def ingress := ⟦ } } - fn canonicalize_addr_map_walk(addrs: List‹Addr›, consts: List‹&Constant›, - seen_mptrs: List‹G›, - seen_addrs: List‹Addr›) -> List‹Addr› { + -- Produce an `Addr → canon_Addr` rbtree keyed by `ptr_val(addr)`. Only + -- members of a Muts wrapper that dedupes to an earlier canonical addr + -- contribute non-trivial entries; non-Muts and primary-wrapper consts + -- map to themselves (and we skip those — `lookup_canon_addr` falls back + -- to the target unchanged on miss). + -- + -- ptr_val keying is sound because Aiur Store content-addresses every + -- pointer: a positive ptr_val match implies content equality. A miss + -- conservatively returns the target (the existing semantics for + -- non-deduped addresses). + fn build_canon_addr_map_walk(addrs: List‹Addr›, consts: List‹&Constant›, + seen_mptrs: List‹G›, + seen_addrs: List‹Addr›, + acc: RBTreeMap‹Addr›) -> RBTreeMap‹Addr› { match load(addrs) { - ListNode.Nil => store(ListNode.Nil), + ListNode.Nil => acc, ListNode.Cons(addr, rest_a) => match load(consts) { ListNode.Cons(c, rest_c) => let mptr = extract_muts_members_ptr(c); - let canon_addr = match mptr { - 0 => addr, - _ => find_canon_addr_for_mptr(mptr, seen_mptrs, seen_addrs, addr), - }; - let new_seen_mptrs = match mptr { - 0 => seen_mptrs, - _ => store(ListNode.Cons(mptr, seen_mptrs)), - }; - let new_seen_addrs = match mptr { - 0 => seen_addrs, - _ => store(ListNode.Cons(canon_addr, seen_addrs)), - }; - store(ListNode.Cons(canon_addr, - canonicalize_addr_map_walk(rest_a, rest_c, new_seen_mptrs, new_seen_addrs))), + match mptr { + 0 => build_canon_addr_map_walk(rest_a, rest_c, seen_mptrs, seen_addrs, acc), + _ => + let canon_addr = find_canon_addr_for_mptr(mptr, seen_mptrs, seen_addrs, addr); + let new_seen_mptrs = store(ListNode.Cons(mptr, seen_mptrs)); + let new_seen_addrs = store(ListNode.Cons(canon_addr, seen_addrs)); + let new_acc = rbtree_map_insert(ptr_val(addr), canon_addr, acc); + build_canon_addr_map_walk(rest_a, rest_c, new_seen_mptrs, new_seen_addrs, new_acc), + }, }, } } - fn canonicalize_addr_map(addrs: List‹Addr›, consts: List‹&Constant›) -> List‹Addr› { - canonicalize_addr_map_walk(addrs, consts, store(ListNode.Nil), store(ListNode.Nil)) + fn build_canon_addr_map(addrs: List‹Addr›, consts: List‹&Constant›) -> RBTreeMap‹Addr› { + build_canon_addr_map_walk(addrs, consts, store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil) } - fn lookup_canon_addr(target: Addr, all_addrs: List‹Addr›, - canon_addrs: List‹Addr›) -> Addr { - match load(all_addrs) { - ListNode.Nil => target, - ListNode.Cons(addr, rest_a) => - match load(canon_addrs) { - ListNode.Cons(canon, rest_c) => - match address_eq(target, addr) { - 1 => canon, - 0 => lookup_canon_addr(target, rest_a, rest_c), - }, - }, + -- O(log N) canon-addr probe. Miss returns target unchanged (the + -- non-deduped case is the common one). + fn lookup_canon_addr(target: Addr, canon_addr_map: &RBTreeMap‹Addr›) -> Addr { + match load(canon_addr_map) { + RBTreeMap.Nil => target, + _ => + let hit = rbtree_map_lookup_or_default(ptr_val(target), load(canon_addr_map), target); + hit, } } @@ -919,14 +918,18 @@ def ingress := ⟦ -- block by extracting the inductive's address from the recursor's typ -- (rather than heuristically matching ctor counts among refs, which fails -- when multiple in-scope inductives share the same number of ctors). + -- Returns `(rule_ctor_idxs, block_addr)`. The standalone-Recr caller + -- needs the block_addr to wrap the CKRecr input; the Muts-block caller + -- already has block_addr in scope and discards the second component. + -- Computing both together saves the standalone caller a redundant + -- `rec_typ_to_inductive_addr` + `load_verified_constant` chain. fn build_aux_recr_ctor_idxs( recr: Recursor, refs: List‹Addr›, sharing: List‹&Expr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G› - ) -> List‹G› { + block_start_map: &RBTreeMap‹G› + ) -> (List‹G›, Addr) { match recr { Recursor.Mk(_, _, _, params, indices, motives, minors, &typ, _) => let n_skip = ((flatten_u64(params) + flatten_u64(motives)) @@ -944,12 +947,13 @@ def ingress := ⟦ Constant.Mk(bi, _, _, _) => match bi { ConstantInfo.Muts(other_members) => - let bs = lookup_block_start(block_addr, block_addrs, block_starts); + let bs = lookup_block_start(block_addr, block_start_map); -- Mutual block: each recursor's rules cover only -- its OWN inductive's ctors. Slice the global -- rule_ctor_idxs to just this member's ctors. - extract_member_ctor_idxs(other_members, bs, - flatten_u64(member_idx)), + let idxs = extract_member_ctor_idxs(other_members, bs, + flatten_u64(member_idx)); + (idxs, block_addr), }, }, }, @@ -998,8 +1002,7 @@ def ingress := ⟦ member_idx: G, refs: List‹Addr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, block_addr: Addr ) -> List‹&ConvertInput› { match mc { @@ -1021,8 +1024,8 @@ def ingress := ⟦ store(ListNode.Cons(store(input), store(ListNode.Nil))), 0 => let sharing = match ctx { ConvertCtx.Mk(s, _, _, _, _) => s, }; - let rule_ctor_idxs = - build_aux_recr_ctor_idxs(recr, refs, sharing, all_addrs, block_addrs, block_starts); + let (rule_ctor_idxs, _) = + build_aux_recr_ctor_idxs(recr, refs, sharing, all_addrs, block_start_map); let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr)); store(ListNode.Cons(store(input), store(ListNode.Nil))), }, @@ -1052,17 +1055,16 @@ def ingress := ⟦ member_idx: G, refs: List‹Addr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, block_addr: Addr ) -> List‹&ConvertInput› { match load(members) { ListNode.Nil => store(ListNode.Nil), ListNode.Cons(mc, rest) => let this = expand_member(mc, ctx, all_members, block_start, member_idx, - refs, all_addrs, block_addrs, block_starts, block_addr); + refs, all_addrs, block_start_map, block_addr); let more = expand_members(rest, ctx, all_members, block_start, member_idx + 1, - refs, all_addrs, block_addrs, block_starts, block_addr); + refs, all_addrs, block_start_map, block_addr); list_concat(this, more), } } @@ -1083,9 +1085,8 @@ def ingress := ⟦ cur_addrs: List‹Addr›, all_addrs: List‹Addr›, pos_map: List‹G›, - canon_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + canon_addr_map: &RBTreeMap‹Addr›, + block_start_map: &RBTreeMap‹G›, pos: G ) -> List‹&ConvertInput› { -- Built once here; threaded as the fast-path index for `lookup_addr_pos`. @@ -1093,10 +1094,12 @@ def ingress := ⟦ -- then walks every const's `refs` and tags every previously-unregistered -- ref with the BLOB sentinel (4294967295), so blob-ref lookups -- short-circuit instead of falling through to the O(N) linear scan. + -- A fused single-pass version was tried and lost — Aiur's per-row width + -- tax made the merged fn more expensive than two narrower passes. let base_map = build_addr_pos_map(all_addrs, pos_map); let addr_pos_map = store(augment_with_blob_refs(consts, base_map)); build_convert_inputs_walk(consts, cur_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos, + canon_addr_map, block_start_map, pos, store(ListNode.Nil)) } @@ -1106,9 +1109,8 @@ def ingress := ⟦ all_addrs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, pos_map: List‹G›, - canon_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + canon_addr_map: &RBTreeMap‹Addr›, + block_start_map: &RBTreeMap‹G›, pos: G, seen_mptrs: List‹G› ) -> List‹&ConvertInput› { @@ -1132,7 +1134,7 @@ def ingress := ⟦ -- emitted). Don't advance pos. Refs to this wrapper -- resolve to canonical pos via pos_map dedup. build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + canon_addr_map, block_start_map, pos, seen_mptrs), 0 => let new_seen = match mptr { 0 => seen_mptrs, @@ -1140,81 +1142,63 @@ def ingress := ⟦ }; let size = block_kernel_size(members); let canon_block_start = lookup_addr_pos(head_addr, addr_pos_map, all_addrs, pos_map); - let canon_addr = lookup_canon_addr(head_addr, all_addrs, canon_addrs); - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let canon_addr = lookup_canon_addr(head_addr, canon_addr_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let recur_idxs = build_recur_idxs(members, canon_block_start, 0); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let expanded = expand_members(members, ctx, members, canon_block_start, 0, - refs, all_addrs, block_addrs, block_starts, canon_addr); + refs, all_addrs, block_start_map, canon_addr); let more = build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos + size, new_seen); + canon_addr_map, block_start_map, pos + size, new_seen); list_concat(expanded, more), }, ConstantInfo.IPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.CPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.RPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.DPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.Defn(defn) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil))); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let hint = #load_constant_hint(head_addr); let input = ConvertInput.Mk(ctx, ConvertKind.CKDefn(defn, hint)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Axio(axio) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKAxio(axio)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Quot(quot) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKQuot(quot)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Recr(recr) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); - -- Resolve the recursor's inductive via typ-based lookup: - -- peel n_skip foralls of `recr.typ` to reach the major's - -- type, take its head, lookup `refs[head_ref_idx]`. The - -- ctor-count heuristic in `find_matching_block_addr` picks - -- the wrong block when multiple in-scope inductives share - -- the same ctor count. - let rule_ctor_idxs = build_aux_recr_ctor_idxs( - recr, refs, sharing, all_addrs, block_addrs, block_starts); - let n_skip = match recr { - Recursor.Mk(_, _, _, params, indices, motives, minors, _, _) => - ((flatten_u64(params) + flatten_u64(motives)) - + flatten_u64(minors)) + flatten_u64(indices), - }; - let typ = match recr { - Recursor.Mk(_, _, _, _, _, _, _, &typ, _) => typ, - }; - let ind_addr = rec_typ_to_inductive_addr(typ, n_skip, refs, sharing); - let ind_const = load_verified_constant(ind_addr); - let block_addr = match ind_const { - Constant.Mk(info, _, _, _) => - match info { - ConstantInfo.IPrj(prj) => - match prj { InductiveProj.Mk(_, ba) => ba, }, - }, - }; + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); + -- `build_aux_recr_ctor_idxs` already does the typ-peel + + -- IPrj lookup to find the recursor's inductive block; + -- get block_addr from the same call instead of redoing + -- the `rec_typ_to_inductive_addr` + `load_verified_constant` + -- chain. + let (rule_ctor_idxs, block_addr) = build_aux_recr_ctor_idxs( + recr, refs, sharing, all_addrs, block_start_map); let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil))); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), }, }, }, @@ -1225,19 +1209,6 @@ def ingress := ⟦ -- Loading and dependency tracking -- ============================================================================ - -- Check if an address is already in a list - fn address_in_list(addr: Addr, list: List‹Addr›) -> G { - match load(list) { - ListNode.Nil => 0, - ListNode.Cons(a, rest) => - let eq = address_eq(addr, a); - match eq { - 1 => 1, - 0 => address_in_list(addr, rest), - }, - } - } - -- Recursively load constants and their transitive dependencies. -- Processes one address at a time from a worklist, deduplicating by -- checking the visited set. Blob addresses are detected via io_get_info: @@ -1312,10 +1283,11 @@ def ingress := ⟦ let (all_addrs, all_consts) = load_with_deps( target_addr, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil); let (block_addrs, block_starts, _total) = compute_layout(all_consts, all_addrs, 0); - let pos_map_naive = build_pos_map(all_consts, all_addrs, block_addrs, block_starts, 0); + let block_start_map = store(build_block_start_map(block_addrs, block_starts)); + let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0); let pos_map = canonicalize_pos_map(all_consts, pos_map_naive); - let canon_addrs = canonicalize_addr_map(all_addrs, all_consts); - let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addrs, block_addrs, block_starts, 0); + let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts)); + let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0); convert_all(inputs) } @@ -1493,7 +1465,7 @@ def ingress := ⟦ -- result or a deterministic loop counter, so the resulting addresses -- are derived from already-trusted data. fn build_ctor_overrides(all_consts: List‹&Constant›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, block_starts: List‹G›) + block_start_map: &RBTreeMap‹G›) -> List‹(G, Addr)› { match load(all_consts) { ListNode.Nil => store(ListNode.Nil), @@ -1506,7 +1478,7 @@ def ingress := ⟦ ConstantInfo.IPrj(prj) => match prj { InductiveProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(bi, _, _, _) => @@ -1517,14 +1489,14 @@ def ingress := ⟦ let n_ctors = inductive_ctor_count_at(members, flatten_u64(idx)); let new_pairs = build_ctor_pairs_computed(idx, block_addr, base_pos, n_ctors, 0); list_concat(new_pairs, - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts)), + build_ctor_overrides(rest_c, rest_a, block_start_map)), _ => - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts), + build_ctor_overrides(rest_c, rest_a, block_start_map), }, }, }, _ => - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts), + build_ctor_overrides(rest_c, rest_a, block_start_map), }, }, }, @@ -1580,47 +1552,9 @@ def ingress := ⟦ store(ListNode.Nil), store(ListNode.Nil)); let bytes = put_constant(cnst, store(ListNode.Nil)); - let h = blake3(bytes); - store([h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3]]) - } - - - -- Walk addrs at increasing positions; if an override exists for the - -- current position, replace the entry. Lets us inject ctor addresses - -- into the per-position address list without restructuring the rest. - fn apply_ctor_overrides(addrs: List‹Addr›, - overrides: List‹(G, Addr)›, pos: G) - -> List‹Addr› { - match load(addrs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(addr, rest) => - let new_addr = lookup_override(overrides, pos, addr); - store(ListNode.Cons(new_addr, - apply_ctor_overrides(rest, overrides, pos + 1))), - } + bytes_to_addr(bytes) } - fn lookup_override(overrides: List‹(G, Addr)›, pos: G, - default: Addr) -> Addr { - match load(overrides) { - ListNode.Nil => default, - ListNode.Cons(p, rest) => - match p { - (op, oaddr) => - match op - pos { - 0 => oaddr, - _ => lookup_override(rest, pos, default), - }, - }, - } - } fn ingress_with_primitives(target_addr: Addr) -> (List‹&KConstantInfo›, List‹Addr›) { let (all_addrs, all_consts) = load_with_deps( @@ -1647,12 +1581,13 @@ def ingress := ⟦ fn finish_ingress(all_addrs: List‹Addr›, all_consts: List‹&Constant›) -> (List‹&KConstantInfo›, List‹Addr›) { let (block_addrs, block_starts, total) = compute_layout(all_consts, all_addrs, 0); - let pos_map_naive = build_pos_map(all_consts, all_addrs, block_addrs, block_starts, 0); + let block_start_map = store(build_block_start_map(block_addrs, block_starts)); + let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0); -- Canonicalize duplicate Muts wrappers (same members-Ptr) so refs -- converge AND emitted KConstantInfos share content via store dedup. let pos_map = canonicalize_pos_map(all_consts, pos_map_naive); - let canon_addrs = canonicalize_addr_map(all_addrs, all_consts); - let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addrs, block_addrs, block_starts, 0); + let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts)); + let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0); let k_consts = convert_all(inputs); -- Build the pos→Addr tree via two O(N) passes (non-PRJ then PRJ -- overwrites at shared positions). Replaces the prior O(N²) @@ -1662,7 +1597,7 @@ def ingress := ⟦ -- CPrj addresses via Lean's compile (non-aux ctors aren't stored in -- env.consts). We surface them via the `[3] ++ ipr_addr` IO-buffer -- side channel and inject them as tree updates. - let overrides = build_ctor_overrides(all_consts, all_addrs, block_addrs, block_starts); + let overrides = build_ctor_overrides(all_consts, all_addrs, block_start_map); let tree = apply_ctor_overrides_tree(overrides, tree); let zero_addr = store([0u8; 32]); let addrs = emit_addrs_from_tree(0, total, tree, zero_addr); diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean index 7122431a..47c6fa57 100644 --- a/Ix/IxVM/Kernel/Claim.lean +++ b/Ix/IxVM/Kernel/Claim.lean @@ -439,22 +439,8 @@ def claim := ⟦ -- `load_verified_constant`: read bytes, recompute blake3, assert -- equality, deserialize, assert no trailing data. fn load_verified_claim(digest: [U8; 32]) -> Claim { - let (idx, len) = io_get_info(0, digest); - let bytes = #read_byte_stream(0, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - digest - ); + let bytes = load_payload_const(digest); + let _ = verify_bytes_against(bytes, digest); let (claim, rest) = get_claim(bytes); assert_eq!(load(rest), ListNode.Nil); claim @@ -467,17 +453,7 @@ def claim := ⟦ -- ============================================================================ fn expr_addr(e_ref: &Expr) -> Addr { let bytes = put_expr(load(e_ref), store(ListNode.Nil)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } -- ============================================================================ @@ -728,33 +704,13 @@ def claim := ⟦ fn leaf_hash(addr: Addr) -> Addr { let tail = put_address(addr, store(ListNode.Nil)); let bytes = store(ListNode.Cons(0u8, tail)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } fn node_hash(l: Addr, r: Addr) -> Addr { let tail = put_address(l, put_address(r, store(ListNode.Nil))); let bytes = store(ListNode.Cons(1u8, tail)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } -- ============================================================================ @@ -780,8 +736,7 @@ def claim := ⟦ fn load_assumption_tree(root: Addr) -> List‹Addr› { let raw = load(root); - let (idx, len) = io_get_info(0, raw); - let bytes = #read_byte_stream(0, idx, len); + let bytes = load_payload_const(raw); let (tag, s) = get_tag4(bytes); let (flag, size) = tag; assert_eq!(flag, 0xE); diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 45ae64e1..86bf6ff7 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -122,53 +122,53 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_715_966), - ("HEq.rec", 2_682_331), - ("Eq.rec", 2_576_284), - ("Nat", 1_858_025), - ("Nat.add", 12_983_943), - ("Nat.add_comm", 54_330_980), - ("Nat.decEq", 68_594_289), - ("Nat.decLe", 191_364_012), - ("Nat.sub_le_of_le_add", 515_130_560), + ("HEq", 1_716_983), + ("HEq.rec", 2_679_377), + ("Eq.rec", 2_574_221), + ("Nat", 1_859_698), + ("Nat.add", 12_945_259), + ("Nat.add_comm", 54_049_773), + ("Nat.decEq", 68_208_022), + ("Nat.decLe", 189_723_325), + ("Nat.sub_le_of_le_add", 510_843_459), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_864_146), - ("Array.append_assoc", 2_566_382_883), - ("Vector.append", 2_638_552_021), + ("Trans.mk", 2_858_716), + ("Array.append_assoc", 2_537_360_311), + ("Vector.append", 2_607_800_745), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 28_082_349), - ("IxVMPrim.nat_sub_lit", 33_722_451), - ("IxVMPrim.nat_mul_lit", 24_644_737), - ("IxVMPrim.nat_mul_big", 24_146_724), - ("IxVMPrim.nat_div_lit", 366_893_945), - ("IxVMPrim.nat_mod_lit", 375_602_678), - ("IxVMPrim.nat_succ_lit", 7_314_408), - ("IxVMPrim.nat_pred_lit", 14_706_095), - ("IxVMPrim.nat_gcd_lit", 605_222_820), - ("IxVMPrim.nat_land_lit", 1_019_495_718), - ("IxVMPrim.nat_lor_lit", 1_020_299_077), - ("IxVMPrim.nat_xor_lit", 1_029_101_731), - ("IxVMPrim.nat_shl_lit", 34_802_946), - ("IxVMPrim.nat_shr_lit", 372_209_350), - ("IxVMPrim.nat_pow_big", 71_850_166), - ("IxVMPrim.nat_beq_lit", 24_145_604), - ("IxVMPrim.nat_ble_lit", 22_475_134), - ("IxVMPrim.nat_dec_le", 198_007_550), - ("IxVMPrim.nat_dec_lt", 201_972_221), - ("IxVMPrim.nat_dec_eq", 82_417_673), - ("IxVMPrim.str_size_lit", 726_987_300), - ("IxVMPrim.bv_to_nat_lit", 576_925_093), + ("IxVMPrim.nat_add_lit", 27_970_389), + ("IxVMPrim.nat_sub_lit", 33_579_674), + ("IxVMPrim.nat_mul_lit", 24_548_790), + ("IxVMPrim.nat_mul_big", 24_051_042), + ("IxVMPrim.nat_div_lit", 363_794_109), + ("IxVMPrim.nat_mod_lit", 372_486_475), + ("IxVMPrim.nat_succ_lit", 7_308_266), + ("IxVMPrim.nat_pred_lit", 14_682_904), + ("IxVMPrim.nat_gcd_lit", 599_766_283), + ("IxVMPrim.nat_land_lit", 1_009_603_192), + ("IxVMPrim.nat_lor_lit", 1_010_406_405), + ("IxVMPrim.nat_xor_lit", 1_019_030_740), + ("IxVMPrim.nat_shl_lit", 34_670_298), + ("IxVMPrim.nat_shr_lit", 369_132_946), + ("IxVMPrim.nat_pow_big", 71_560_887), + ("IxVMPrim.nat_beq_lit", 24_061_127), + ("IxVMPrim.nat_ble_lit", 22_388_890), + ("IxVMPrim.nat_dec_le", 196_255_925), + ("IxVMPrim.nat_dec_lt", 200_203_243), + ("IxVMPrim.nat_dec_eq", 81_874_028), + ("IxVMPrim.str_size_lit", 716_814_982), + ("IxVMPrim.bv_to_nat_lit", 571_422_589), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_974_275), - ("IxVMInd.Odd", 25_737_413), - ("IxVMInd.Even.rec", 31_628_577), - ("IxVMInd.Odd.rec", 31_627_681), + ("IxVMInd.Even", 25_861_665), + ("IxVMInd.Odd", 25_621_808), + ("IxVMInd.Even.rec", 31_434_525), + ("IxVMInd.Odd.rec", 31_433_622), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_635_546), - ("IxVMInd.Tree.rec", 4_874_311), + ("IxVMInd.Tree", 2_641_542), + ("IxVMInd.Tree.rec", 4_867_794), -- Edge cases from prelude - ("String.Internal.append", 718_452_811), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_081_131_375), + ("String.Internal.append", 708_296_270), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_064_689_765), ] private def nameOfString (str : String) : Lean.Name := From ee4da06b6e1baea2ab8f93132225ce130e0b1d29 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Sat, 27 Jun 2026 15:38:37 -0700 Subject: [PATCH 04/11] IxVM: per-kind IOBuffer channels with documented interface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replaces channel 0's tagged-union (claim / tree / const bytes / empty- blob-marker, distinguished only by key content-hash collision- impossibility) with one channel per value kind. Channel reorganization is cost-neutral — all six per-channel `io_get_info` + `#read_byte_stream` pairs are inlined at the single consumer of each channel, so no fn-call row gets added. New layout, tiered by access pattern: | Tier | Channel | Purpose | Key | Value | |-------|---------|--------------------------|-------------------------|----------------------| | Ctrl | 0 | claim wire bytes | `blake3(claim_bytes)` | claim bytes | | Ctrl | 1 | assumption tree bytes | `tree.root` | tree bytes | | Const | 2 | constant wire bytes | const addr | const bytes | | Const | 3 | Defn reducibility hint | Defn addr | single G | | Blob | 4 | blob discriminator | addr | one byte (1=const, 0=blob) | | Blob | 5 | blob raw bytes | blob addr | raw bytes | Tier 1 = one-per-`verify_claim`. Tier 2 = per-const. Tier 3 = per-blob. `io_get_info(channel, key)` is now unambiguous by channel alone. Aiur side (`Ingress.lean`, `Kernel/Claim.lean`): * `load_verified_constant` inlines `io_get_info(2, raw)` + `#read_byte_stream(2, ...)` (was ch 0). * `load_verified_blob` inlines ch 5 read (was ch 1). * `load_constant_hint` inlines ch 3 read (was ch 2). * `load_with_deps` inlines a ch 4 discriminator probe replacing the former `io_get_info(0, addr).len == 0 ⟹ blob` hack on ch 0. One read_byte for the per-addr discriminator byte. * `load_verified_claim` inlines ch 0 (was using a shared `load_payload_const` helper on ch 0). * `load_assumption_tree` inlines ch 1 (was using same `load_payload_const` helper on ch 0). * Helper wrappers (`load_payload_claim/tree/const/hint/blob`, `load_discriminator`, `ch_*` constants) all removed — every channel has exactly one consumer site and the inlined dispatch costs no fn call. * Top-of-file `IxVM IOBuffer interface` doc block documents the layout + soundness model. Lean side (`ClaimHarness.lean`): * `addEntries` writes per channel — consts → ch 2 + per-addr discriminator `[1]` on ch 4; blobs → ch 5 + per-addr discriminator `[0]` on ch 4; Defn hints → ch 3. * `seedTreeAt` writes tree bytes to ch 1 (was ch 0). * `buildClaimWitness` writes claim bytes to ch 0 (unchanged). * Drops the empty-marker write on ch 0 for blob addrs — the ch 4 discriminator covers blob/const classification explicitly. * Top-of-section `IxVM IOBuffer interface` doc block mirrors the Aiur-side comment. Soundness model unchanged. ch 0/1/2/5 byte streams are blake3-verified by the kernel against their content-addressed keys. ch 3 hint is semantically optional (controls WHNF reduction heuristic only; def-eq is sound either way). ch 4 discriminator is sound by erasure- correctness — a lying byte flips the const/blob decision and the wrong-path load downstream fails (a "const" blob triggers a ch 2 read that returns empty → blake3 verify against the non-empty addr fails; a "blob" const dangles references → typecheck fail). `lake test -- --ignored ixvm` green; 42 pins shifted within ±0.010% (noise-tier) vs the pre-shuffle baseline — channel reorganization is cost-neutral as required, the discriminator's one read_byte trades against the eliminated `io_get_info(0, ...).len` check. --- Ix/IxVM/ClaimHarness.lean | 63 ++++++++++++++++++------- Ix/IxVM/Ingress.lean | 96 +++++++++++++++++++++++++-------------- Ix/IxVM/Kernel/Claim.lean | 8 +++- Tests/Ix/IxVM.lean | 84 +++++++++++++++++----------------- 4 files changed, 156 insertions(+), 95 deletions(-) diff --git a/Ix/IxVM/ClaimHarness.lean b/Ix/IxVM/ClaimHarness.lean index 1aff93d5..55e29ce1 100644 --- a/Ix/IxVM/ClaimHarness.lean +++ b/Ix/IxVM/ClaimHarness.lean @@ -124,19 +124,45 @@ private def hintToG : Lean.ReducibilityHints → Aiur.G | .abbrev => .ofNat 0xFFFFFFFF | .regular n => .ofNat (min (1 + n.toNat) 0xFFFFFFFE) +/-! ## IxVM IOBuffer interface + +The host seeds blake3-keyed payloads on six channels; the Aiur kernel +consumes them via `io_get_info` + `#read_byte_stream`. One value shape +per channel — no overloading, no in-band discriminators. + +Tiered by access pattern (matches kernel runtime order): + +| Tier | Channel | Purpose | Key (32 G) | Value shape | +|--------|---------|--------------------------|-------------------------|-------------------| +| Ctrl | 0 | claim wire bytes | `blake3(claim_bytes)` | claim bytes | +| Ctrl | 1 | assumption tree bytes | `tree.root` | tree bytes | +| Const | 2 | constant wire bytes | const addr | const bytes | +| Const | 3 | Defn reducibility hint | Defn addr | single G | +| Blob | 4 | blob discriminator | addr | one byte (1=const, 0=blob) | +| Blob | 5 | blob raw bytes | blob addr | raw bytes | + +Tier 1 fires once per `verify_claim` invocation (claim + optional tree). +Tier 2 fires per constant traversed during `load_with_deps`. Tier 3 +fires per blob ref encountered during `build_ref_idxs_and_blobs`. + +Soundness: +* ch 0/1/2/5 — every byte stream is blake3-verified by the kernel + against its content-addressed key. +* ch 3 — semantically optional; controls WHNF reduction heuristic + only, def-eq is sound either way. +* ch 4 — sound by erasure-correctness: a lying discriminator flips + the const/blob decision and the wrong-path load downstream fails + (a "const" blob triggers a ch 2 read returning empty → blake3 + verify against the non-empty addr fails; a "blob" const dangles + references → typecheck fail). + +Channel numbers MUST stay in sync with the inlined `io_get_info` / +`#read_byte_stream` channel literals in `Ix/IxVM/Ingress.lean` and +`Ix/IxVM/Kernel/Claim.lean`. +-/ + /-- Insert all per-address entries for `addr`s satisfying `keep` into - `ioBuffer`. Each address kind lives on its own channel; the key is - always the 32-G blake3 hash, with no disambiguating suffix. - - | channel | key (32 G) | value | meaning | - |---------|------------|----------------|---------| - | 0 | `addr` | const bytes | constant data (empty marker = `addr` is a blob) | - | 1 | `addr` | raw blob bytes | referenced data (verified by Aiur via blake3) | - | 2 | `addr` | single G | Defn `ReducibilityHints` encoding | - - Blob addrs also get an empty entry on channel 0 so the kernel's - constant-vs-blob detection (`io_get_info(0, addr) ⇒ len=0`) still - works without a separate query path. -/ + `ioBuffer`. See the channel table above. -/ def addEntries (ixonEnv : Ixon.Env) (keep : Address → Bool) (ioBuffer : Aiur.IOBuffer) : Aiur.IOBuffer := Id.run do let mut ioBuffer := ioBuffer @@ -146,18 +172,21 @@ def addEntries (ixonEnv : Ixon.Env) (keep : Address → Bool) -- serialized form the lazy entry holds — no materialization needed. let bytes := lc.rawBytes let key : Array Aiur.G := addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 0 key (bytes.data.map .ofUInt8) + ioBuffer := ioBuffer.extend 2 key (bytes.data.map .ofUInt8) + -- Discriminator: this addr resolves to a constant. + ioBuffer := ioBuffer.extend 4 key #[.ofNat 1] for (addr, rawBytes) in ixonEnv.blobs do if !keep addr then continue let key : Array Aiur.G := addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 1 key (rawBytes.data.map fun b => .ofNat b.toNat) - ioBuffer := ioBuffer.extend 0 key #[] + ioBuffer := ioBuffer.extend 5 key (rawBytes.data.map fun b => .ofNat b.toNat) + -- Discriminator: this addr resolves to a blob. + ioBuffer := ioBuffer.extend 4 key #[.ofNat 0] for (_, named) in ixonEnv.named do if !keep named.addr then continue match named.constMeta with | .defn _ _ hints _ _ _ _ _ => let key : Array Aiur.G := named.addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 2 key #[hintToG hints] + ioBuffer := ioBuffer.extend 3 key #[hintToG hints] | _ => pure () return ioBuffer @@ -189,7 +218,7 @@ private def seedTreeAt (root : Address) match trees.get? root with | some tree => let bytes := Ix.AssumptionTree.ser tree - .ok (ioBuffer.extend 0 (addrKey tree.root) (bytes.data.map .ofUInt8)) + .ok (ioBuffer.extend 1 (addrKey tree.root) (bytes.data.map .ofUInt8)) | none => .error s!"no assumption tree supplied for root {root}" /-- Build the witness for `verify_claim` against `claim`. diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean index 32854a8a..5d038da4 100644 --- a/Ix/IxVM/Ingress.lean +++ b/Ix/IxVM/Ingress.lean @@ -9,41 +9,58 @@ namespace IxVM def ingress := ⟦ -- IOBuffer channel identifiers. See `ClaimHarness.lean` for the host-side -- counterpart that seeds these channels. - fn ch_const() -> G { 0 } - fn ch_blob() -> G { 1 } - fn ch_hint() -> G { 2 } - - -- Read the raw bytes the prover seeded at `key` on `channel`. - -- Channels and keys are documented per call site; the helper exists - -- only to centralise the `io_get_info` + `#read_byte_stream` pair. - fn load_payload_const(key: [U8; 32]) -> ByteStream { - let (idx, len) = io_get_info(0, key); - #read_byte_stream(0, idx, len) - } - fn load_payload_blob(key: [U8; 32]) -> ByteStream { - let (idx, len) = io_get_info(1, key); - #read_byte_stream(1, idx, len) - } - fn load_payload_hint(key: [U8; 32]) -> ByteStream { - let (idx, len) = io_get_info(2, key); - #read_byte_stream(2, idx, len) - } + -- ============================================================================ + -- IxVM IOBuffer interface + -- + -- The host (Lean `IxVM.ClaimHarness`) seeds blake3-keyed payloads on six + -- channels; the kernel consumes them via `io_get_info` + `#read_byte_stream`. + -- One value shape per channel — no overloading, no in-band discriminators. + -- + -- Tiered by access pattern (matches kernel runtime order): + -- + -- Tier 1 — control input (one-per-run): + -- ch 0 claim wire bytes key = blake3(claim_bytes) value = claim bytes + -- ch 1 assumption tree bytes key = tree.root value = tree bytes + -- + -- Tier 2 — per-const data: + -- ch 2 constant wire bytes key = const.addr value = const bytes + -- ch 3 Defn reducibility hint key = defn.addr value = [hint_G] + -- + -- Tier 3 — per-blob data: + -- ch 4 blob discriminator key = addr value = [1=const,0=blob] + -- ch 5 blob raw bytes key = blob.addr value = raw bytes + -- + -- Soundness: every kernel-consumed byte stream is blake3-verified + -- against its key (ch 0/1/2/5). ch 3 hint is semantically optional + -- (controls WHNF heuristic only; def-eq is sound either way). ch 4 + -- discriminator is sound by erasure-correctness: lying flips the + -- const/blob decision and the wrong-path load fails downstream. + -- + -- Per-channel access patterns are inlined at each consumer (one site + -- per channel) so the dispatch never crosses a fn boundary — channel + -- choice doesn't add Aiur per-row width tax. Each `io_get_info` + + -- `#read_byte_stream` pair appears once at the producer call site. + -- Channel numbers MUST stay in sync with `Ix/IxVM/ClaimHarness.lean`. + -- ============================================================================ - -- Load a constant from IOBuffer by address, verify blake3, deserialize. + -- Load a constant from IOBuffer by address (ch 2), verify blake3, + -- deserialize. fn load_verified_constant(addr: Addr) -> Constant { let raw = load(addr); - let bytes = load_payload_const(raw); + let (idx, len) = io_get_info(2, raw); + let bytes = #read_byte_stream(2, idx, len); let _ = verify_bytes_against(bytes, raw); let (constant, rest) = get_constant(bytes); assert_eq!(load(rest), ListNode.Nil); constant } - -- Load a blob from IOBuffer by address, verify blake3, return raw bytes. - -- Blobs live on channel 1; constants live on channel 0 with the same key. + -- Load a blob from IOBuffer by address (ch 5), verify blake3, return + -- raw bytes. fn load_verified_blob(addr: Addr) -> ByteStream { let raw = load(addr); - let bytes = load_payload_blob(raw); + let (idx, len) = io_get_info(5, raw); + let bytes = #read_byte_stream(5, idx, len); let _ = verify_bytes_against(bytes, raw); bytes } @@ -99,15 +116,17 @@ def ingress := ⟦ } } - -- Load reducibility hint G for a Defn at `addr`. Lives on channel 2. - -- Encoding (mirror Lean.ReducibilityHints): + -- Load reducibility hint G for a Defn at `addr` (ch 3). Encoding + -- mirrors `Lean.ReducibilityHints`: -- 0 = Opaque -- 1 + h = Regular(h) -- 0xFFFFFFFF = Abbrev - -- Caller MUST only invoke this for Defn addrs; the harness only seeds - -- channel 2 for defns. A missing key aborts execution (correct). + -- Caller MUST only invoke this for Defn addrs; the harness only + -- seeds ch 3 for Defns. A missing key aborts execution (correct). fn load_constant_hint(addr: Addr) -> G { - let bytes = load_payload_hint(load(addr)); + let raw = load(addr); + let (idx, len) = io_get_info(3, raw); + let bytes = #read_byte_stream(3, idx, len); match load(bytes) { ListNode.Cons(b, _) => to_field(b), } @@ -1231,11 +1250,20 @@ def ingress := ⟦ load_with_deps(next, rest, visited_addrs, visited_consts, visited_set), }, _ => - -- Check if this address has constant data in IOBuffer. - -- io_get_info is unconstrained; the prover provides (0, 0) for blob addresses. - -- Soundness: if the prover lies and skips a real constant, type checking will fail. - let (_, len) = io_get_info(0, load(addr)); - match len { + -- Discriminator on ch 4: 1 = const, 0 = blob. The host + -- (`addEntries`) seeds exactly one byte per addr it ships. + -- Soundness via erasure-correctness: lying flips the const/blob + -- decision, and the wrong-path load fails downstream (a "blob" + -- const won't get its bytes ingressed → refs to it dangle → + -- typecheck fail; a "const" blob triggers a ch 2 read that + -- returns empty → blake3 verify against the non-empty addr + -- fails). + let (idx, len) = io_get_info(4, load(addr)); + let kind_bytes = #read_byte_stream(4, idx, len); + let kind = match load(kind_bytes) { + ListNode.Cons(b, _) => to_field(b), + }; + match kind { 0 => -- Blob address: skip (blob values are loaded on demand in build_lit_blobs) match load(worklist) { diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean index 47c6fa57..ccfc9d15 100644 --- a/Ix/IxVM/Kernel/Claim.lean +++ b/Ix/IxVM/Kernel/Claim.lean @@ -438,8 +438,11 @@ def claim := ⟦ -- Load + verify a claim from the IOBuffer at key=`digest`. Mirrors -- `load_verified_constant`: read bytes, recompute blake3, assert -- equality, deserialize, assert no trailing data. + -- Load + verify a claim from IOBuffer at `digest` (ch 0). Reads bytes, + -- recomputes blake3, asserts equality, deserialises. fn load_verified_claim(digest: [U8; 32]) -> Claim { - let bytes = load_payload_const(digest); + let (idx, len) = io_get_info(0, digest); + let bytes = #read_byte_stream(0, idx, len); let _ = verify_bytes_against(bytes, digest); let (claim, rest) = get_claim(bytes); assert_eq!(load(rest), ListNode.Nil); @@ -736,7 +739,8 @@ def claim := ⟦ fn load_assumption_tree(root: Addr) -> List‹Addr› { let raw = load(root); - let bytes = load_payload_const(raw); + let (idx, len) = io_get_info(1, raw); + let bytes = #read_byte_stream(1, idx, len); let (tag, s) = get_tag4(bytes); let (flag, size) = tag; assert_eq!(flag, 0xE); diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 86bf6ff7..46af36c5 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -122,53 +122,53 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_716_983), - ("HEq.rec", 2_679_377), - ("Eq.rec", 2_574_221), - ("Nat", 1_859_698), - ("Nat.add", 12_945_259), - ("Nat.add_comm", 54_049_773), - ("Nat.decEq", 68_208_022), - ("Nat.decLe", 189_723_325), - ("Nat.sub_le_of_le_add", 510_843_459), + ("HEq", 1_716_804), + ("HEq.rec", 2_678_994), + ("Eq.rec", 2_573_838), + ("Nat", 1_859_519), + ("Nat.add", 12_944_048), + ("Nat.add_comm", 54_047_004), + ("Nat.decEq", 68_205_533), + ("Nat.decLe", 189_722_204), + ("Nat.sub_le_of_le_add", 510_870_092), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_858_716), - ("Array.append_assoc", 2_537_360_311), - ("Vector.append", 2_607_800_745), + ("Trans.mk", 2_858_426), + ("Array.append_assoc", 2_537_478_644), + ("Vector.append", 2_607_925_682), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 27_970_389), - ("IxVMPrim.nat_sub_lit", 33_579_674), - ("IxVMPrim.nat_mul_lit", 24_548_790), - ("IxVMPrim.nat_mul_big", 24_051_042), - ("IxVMPrim.nat_div_lit", 363_794_109), - ("IxVMPrim.nat_mod_lit", 372_486_475), - ("IxVMPrim.nat_succ_lit", 7_308_266), - ("IxVMPrim.nat_pred_lit", 14_682_904), - ("IxVMPrim.nat_gcd_lit", 599_766_283), - ("IxVMPrim.nat_land_lit", 1_009_603_192), - ("IxVMPrim.nat_lor_lit", 1_010_406_405), - ("IxVMPrim.nat_xor_lit", 1_019_030_740), - ("IxVMPrim.nat_shl_lit", 34_670_298), - ("IxVMPrim.nat_shr_lit", 369_132_946), - ("IxVMPrim.nat_pow_big", 71_560_887), - ("IxVMPrim.nat_beq_lit", 24_061_127), - ("IxVMPrim.nat_ble_lit", 22_388_890), - ("IxVMPrim.nat_dec_le", 196_255_925), - ("IxVMPrim.nat_dec_lt", 200_203_243), - ("IxVMPrim.nat_dec_eq", 81_874_028), - ("IxVMPrim.str_size_lit", 716_814_982), - ("IxVMPrim.bv_to_nat_lit", 571_422_589), + ("IxVMPrim.nat_add_lit", 27_965_913), + ("IxVMPrim.nat_sub_lit", 33_575_354), + ("IxVMPrim.nat_mul_lit", 24_546_472), + ("IxVMPrim.nat_mul_big", 24_048_795), + ("IxVMPrim.nat_div_lit", 363_810_437), + ("IxVMPrim.nat_mod_lit", 372_503_418), + ("IxVMPrim.nat_succ_lit", 7_306_831), + ("IxVMPrim.nat_pred_lit", 14_680_455), + ("IxVMPrim.nat_gcd_lit", 599_806_695), + ("IxVMPrim.nat_land_lit", 1_009_687_743), + ("IxVMPrim.nat_lor_lit", 1_010_490_897), + ("IxVMPrim.nat_xor_lit", 1_019_114_634), + ("IxVMPrim.nat_shl_lit", 34_666_438), + ("IxVMPrim.nat_shr_lit", 369_149_913), + ("IxVMPrim.nat_pow_big", 71_556_071), + ("IxVMPrim.nat_beq_lit", 24_057_793), + ("IxVMPrim.nat_ble_lit", 22_385_742), + ("IxVMPrim.nat_dec_le", 196_255_439), + ("IxVMPrim.nat_dec_lt", 200_202_805), + ("IxVMPrim.nat_dec_eq", 81_870_937), + ("IxVMPrim.str_size_lit", 716_854_159), + ("IxVMPrim.bv_to_nat_lit", 571_458_745), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_861_665), - ("IxVMInd.Odd", 25_621_808), - ("IxVMInd.Even.rec", 31_434_525), - ("IxVMInd.Odd.rec", 31_433_622), + ("IxVMInd.Even", 25_857_751), + ("IxVMInd.Odd", 25_617_894), + ("IxVMInd.Even.rec", 31_430_086), + ("IxVMInd.Odd.rec", 31_429_183), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_641_542), - ("IxVMInd.Tree.rec", 4_867_794), + ("IxVMInd.Tree", 2_641_130), + ("IxVMInd.Tree.rec", 4_866_817), -- Edge cases from prelude - ("String.Internal.append", 708_296_270), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_064_689_765), + ("String.Internal.append", 708_332_683), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_064_762_809), ] private def nameOfString (str : String) : Lean.Name := From 83b5d31fd88fff809931165cdf66923486a329d7 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 05:10:33 -0700 Subject: [PATCH 05/11] =?UTF-8?q?Aiur=20Bytecode=20=E2=86=92=20Rust=20code?= =?UTF-8?q?gen=20for=20the=20IxVM=20kernel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds a new Aiur pipeline stage that translates `Bytecode.Toplevel` into a Rust source module, one `fn aiur_fn_N` per Aiur function. The generated code mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly: same `function_queries.insert` timing, same cache-hit multiplicity bumps, same memory-queries insertion order, same `bytes{1,2}_queries` updates, same IO sequencing. Per-witness trace hashes match the interpreter byte-for-byte on every const tested (`Nat.add_comm`, `Vector.append`, `Std.Time.Week.Offset.ofMilliseconds`). * `Ix/Aiur/Stages/Codegen.lean`: structured Rust IR (`RustExpr` / `RustStmt` / `RustItem` / `MatchArm` / labeled blocks) plus a formatter. Codegen is a structural walk over the Bytecode AST, no string templating. `EmitM = StateM EmitState` threads `(nextVal, nextLabel)` so per-ValIdx Rust locals and per-MC labels are fresh. * Aiur's `map: Vec` is gone in the generated kernel: every ValIdx becomes a Rust local `__v_{i}: G`. Match-arm bodies snapshot `nextVal` on entry so per-arm allocations don't leak to siblings. `MatchContinue` / `Yield` use labeled-block + `break 'label [G; OUT_SIZE]` to bubble yielded values out and rebind them at outer scope. * Deep Aiur recursion uses `stacker::maybe_grow(64 KiB, 4 MiB, …)` at the top of every generated fn, so the native call stack grows on demand rather than pre-reserving a giant thread stack. Verified against shard 24 of the 64-way `init.ixes` partition, which SEGFAULTs without it. * `ix codegen`: new CLI command. Compiles the IxVM Aiur source, walks the bytecode, writes the generated Rust to a fixed path (`src/ix/aiur_ixvm.rs`). The output path is hard-coded; no override. * `src/ix/aiur_ixvm.rs`: the generated kernel, 743 `aiur_fn_*` + `execute_generated` dispatch. Auto-regenerated; do not edit. `#![cfg_attr(rustfmt, rustfmt::skip)]` + a broad `#![allow(unused_*, non_snake_case, clippy::all)]` since the layout is for the compiler, not humans. * `src/ix/aiur_ixvm_runner.rs`: `execute_ixvm(toplevel, fun_idx, args, io_buffer) -> Result<(QueryRecord, Vec), ExecError>`. Same return shape as `Toplevel::execute`, but routes through `execute_generated`. * `src/aiur/synthesis.rs`: `AiurSystem::prove_ixvm(...)` — same shape as `prove`, but the execute step calls `execute_ixvm`. Verification-compatible (proofs from one path verify under the other). * `src/aiur/execute.rs`: helpers exposed for the codegen'd kernel (`bytes{1,2}_execute` → `pub(crate)`, `unconstrained_big_uint_div_mod_helper` extracted, `CodegenBytes{1,2}{Op,}` aliases re-exported, `QueryRecord::new` → `pub(crate)`, `ExecError::InvalidFunIdx` added). * `src/ffi/aiur/protocol.rs`: two new FFI exports — `rs_aiur_toplevel_execute_ixvm` and `rs_aiur_system_prove_ixvm`. Same wire format as the existing `_execute` / `prove` exports. * `Ix/Aiur/Semantics/BytecodeFfi.lean`: `Bytecode.Toplevel.executeIxVM` — mirror of `execute`. * `Ix/Aiur/Protocol.lean`: `AiurSystem.proveIxVM`. * `Ix/Cli/CheckCmd.lean`: `runCompiled` now dispatches through `executeIxVM`. The Rust bytecode interpreter is no longer reachable from `ix check` (the Lean-side `--interp` fallback stays for richer error diagnostics). * `Ix/Cli/ProveCmd.lean`: `proveOne` uses `proveIxVM`. * `Cargo.toml`: `stacker = "0.1"`. For witnesses where execute is the dominant work (single-const checks via `ix check 'X'`), the codegen'd kernel is ~1.6× faster than the bytecode interpreter end-to-end (measured on `Nat.add_comm`, `Vector.append`, `Std.Time.Week.Offset.ofMilliseconds`). Tiny consts are within ~10% (stacker probe overhead amortises). Peak RSS is within a few MB of the interpreter — stacker grows the stack on demand, no giant upfront reservation. For shard-driven `ix check --shard K` runs the speedup is invisible: per-shard wall time is dominated (~92%) by `buildShardCheckEnvWitness` in Lean, NOT by the kernel execute (~8%). Cutting witness construction is the next lever. `Nat.add_comm` proof produced via `proveIxVM` verifies under the existing `AiurSystem::verify`. End-to-end: lake exe ix prove 'Nat.add_comm' → proof addr 0d0ab0f9… lake exe ix verify 0d0ab0f9… → ok --- Cargo.lock | 61 +- Cargo.toml | 2 + Ix/Aiur/Protocol.lean | 23 + Ix/Aiur/Semantics/BytecodeFfi.lean | 30 + Ix/Aiur/Stages/Codegen.lean | 939 + Ix/Cli/CheckCmd.lean | 10 +- Ix/Cli/CodegenCmd.lean | 60 + Ix/Cli/ProveCmd.lean | 5 +- Main.lean | 2 + crates/aiur/src/execute.rs | 57 +- crates/aiur/src/gadgets/bytes1.rs | 12 +- crates/aiur/src/gadgets/bytes2.rs | 30 +- crates/aiur/src/querymap.rs | 4 +- crates/aiur/src/synthesis.rs | 78 +- crates/ffi/Cargo.toml | 1 + crates/ffi/src/aiur/protocol.rs | 104 + crates/ix/Cargo.toml | 19 + crates/ix/src/aiur_ixvm.rs | 68427 +++++++++++++++++++++++++++ crates/ix/src/aiur_ixvm_runner.rs | 39 + crates/ix/src/lib.rs | 6 + 20 files changed, 69871 insertions(+), 38 deletions(-) create mode 100644 Ix/Aiur/Stages/Codegen.lean create mode 100644 Ix/Cli/CodegenCmd.lean create mode 100644 crates/ix/Cargo.toml create mode 100644 crates/ix/src/aiur_ixvm.rs create mode 100644 crates/ix/src/aiur_ixvm_runner.rs create mode 100644 crates/ix/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 13f6bf3b..bc102b9c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -81,6 +81,15 @@ version = "1.0.103" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3" +[[package]] +name = "ar_archive_writer" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348" +dependencies = [ + "object", +] + [[package]] name = "arrayref" version = "0.3.9" @@ -1731,6 +1740,21 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "ix" +version = "0.1.0" +dependencies = [ + "aiur", + "dashmap", + "ix-common", + "ixon", + "multi-stark", + "num-bigint", + "rayon", + "rustc-hash", + "stacker", +] + [[package]] name = "ix-common" version = "0.1.0" @@ -1778,6 +1802,7 @@ dependencies = [ "iroh", "iroh-base", "itertools 0.14.0", + "ix", "ix-common", "ix-compile", "ix-kernel", @@ -2431,6 +2456,15 @@ dependencies = [ "objc2-security", ] +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -2958,6 +2992,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "psm" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea" +dependencies = [ + "ar_archive_writer", + "cc", +] + [[package]] name = "quick-xml" version = "0.39.4" @@ -3254,7 +3298,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -3557,6 +3601,19 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" +[[package]] +name = "stacker" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "640c8cdd92b6b12f5bcb1803ca3bbf5ab96e5e6b6b96b9ab77dabe9e880b3190" +dependencies = [ + "cc", + "cfg-if", + "libc", + "psm", + "windows-sys 0.61.2", +] + [[package]] name = "strength_reduce" version = "0.2.4" @@ -3640,7 +3697,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" dependencies = [ "rustix", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index e3a2ae7f..b01f8ae2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ members = [ "crates/common", "crates/compile", "crates/ffi", + "crates/ix", "crates/ixon", "crates/kernel", ] @@ -27,6 +28,7 @@ license = "MIT OR Apache-2.0" [workspace.dependencies] # Internal crates aiur = { path = "crates/aiur" } +ix = { path = "crates/ix" } ix-common = { path = "crates/common" } ix-compile = { path = "crates/compile" } ixon = { path = "crates/ixon" } diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 7bfdd5df..1170b1d5 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -73,6 +73,29 @@ def prove (system : @& AiurSystem) (friParameters : @& FriParameters) let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ (claim, proof, ⟨ioData, ioMap⟩) +@[extern "rs_aiur_system_prove_ixvm"] +private opaque proveIxVM' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& Array G → + (ioData : @& Array (G × Array G)) → + (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + Array G × Proof × Array (G × Array G) × Array ((G × Array G) × IOKeyInfo) + +/-- IxVM-native prove: same shape as `prove`, but routes execution + through the codegen'd Rust kernel (`execute_generated`) instead + of the bytecode interpreter. The resulting `Proof` is + verification-compatible with one from `prove`. Only valid when + `system.toplevel` is the IxVM kernel's bytecode. -/ +def proveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : + Array G × Proof × IOBuffer := + let ioData := ioBuffer.data.toArray + let ioMap := ioBuffer.map.toArray + let (claim, proof, ioData, ioMap) := proveIxVM' system friParameters funIdx args + ioData ioMap + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + (claim, proof, ⟨ioData, ioMap⟩) + @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @& FriParameters → @& Array G → @& Proof → Except String Unit diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index e3970d70..2c7d2e9f 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -96,6 +96,36 @@ def execute (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) +@[extern "rs_aiur_toplevel_execute_ixvm"] +private opaque executeIxVM' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& Array G → + (ioData : @& Array (G × Array G)) → + (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + +/-- IxVM-native execution: same shape as `execute`, but routes the + function invocation through the codegen'd Rust kernel + (`crate::ix::aiur_ixvm::execute_generated`) instead of the + generic bytecode interpreter. The resulting `QueryRecord` is + byte-for-byte identical (modulo the standing codegen parity + invariant). Only valid when `toplevel` is the IxVM kernel's + `Bytecode.Toplevel` — other toplevels produce undefined results + because the generated function bodies are fixed at codegen time. -/ +def executeIxVM (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : + Except String (Array G × IOBuffer × Array QueryCount) := + let ioData := ioBuffer.data.toArray + let ioMap := ioBuffer.map.toArray + match executeIxVM' toplevel funIdx args ioData ioMap with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean new file mode 100644 index 00000000..48679311 --- /dev/null +++ b/Ix/Aiur/Stages/Codegen.lean @@ -0,0 +1,939 @@ +/- + Aiur bytecode → Rust source codegen. + + Next stage after `Bytecode`. Walks a `Bytecode.Toplevel` and emits one + Rust fn per Aiur function: + + ```rust + fn aiur_fn_N( + inp: [G; INPUT_SIZE], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, + ) -> [G; OUTPUT_SIZE] + ``` + + `INPUT_SIZE = Function.layout.inputSize`. `OUTPUT_SIZE` derived from + the function's `Ctrl.return` arms (Aiur fn layouts are fixed; all + Returns within a fn agree). + + Architecture: build a structured Rust IR (`RustExpr` / `RustStmt` / + `RustItem`) by walking the Bytecode, then format the IR to a single + Rust source `String` at the end. No string interpolation during + codegen — collect IR, dispatch to string late. + + # Correctness invariant + + Generated code MUST produce a `QueryRecord` indistinguishable from + `src/aiur/execute.rs`'s interpreter: + + - `function_queries[idx].insert(args, output, mult)` MUST happen on + `Ctrl::Return` of the callee, AFTER the callee's body's inserts. + - Cache-hit `multiplicity += G::ONE` MUST trigger iff + `!unconstrained && !op_unconstrained` for `Op::Call`, and + `!unconstrained` for `Op::Store` / `Op::Load`. + - `memory_queries[size]` insertion order: each unique store gets a + pointer = `memory_queries.len()` at that moment. + - `bytes1_queries` / `bytes2_queries` updates from `U8*` ops in + constrained mode, suppressed when `unconstrained == true`. + - `io_buffer` ops preserve order. + + # `unconstrained` propagation + + `unconstrained: bool` is the fn-local flag. Once `true`, stays `true`. + Each `Op::Call(callee, args, _, op_unconstrained)` invokes the callee + with `unconstrained || op_unconstrained`. + + # Status + + Skeleton: Rust IR + formatter. A few Op variants (`Const`, `Add` / + `Sub` / `Mul`, `EqZero`) emit faithful IR. `Ctrl::Return` + `Ctrl::Match` + emit faithful IR. + + Remaining (mechanical fill-in following the same IR shape): + - `Op::Call` cache-check via `ifLetSome` (needs IR extension) + - `Op::Store` / `Op::Load` / `Op::AssertEq` + - IO ops: `IOGetInfo`, `IOSetInfo`, `IORead`, `IOWrite` + - Byte ops: all `U8*` + `U32LessThan` (gated on `unconstrained`) + - `UnconstrainedBigUintDivMod`, `Debug` + - `Ctrl::MatchContinue` + `Ctrl::Yield` (needs `BlockResult` enum) + + Parity test BEFORE wiring into the build: generate code for one small + Aiur fn, run both backends on the same input, diff the resulting + `QueryRecord` byte-for-byte. Diverging records ⇒ invalid witnesses + ⇒ proving fails hard. +-/ +module +public import Ix.Aiur.Stages.Bytecode + +public section + +namespace Aiur.Codegen + +open Bytecode + +/-! ## Rust IR -/ + +mutual + +inductive RustExpr where + /-- A bare identifier (e.g. `record`, `__args`). -/ + | var (name : String) + /-- A literal emitted verbatim (numbers, strings, `true`, `false`). -/ + | lit (text : String) + /-- Path: `G::ZERO`, `ExecError::MatchNoCase`, etc. -/ + | path (segments : Array String) + /-- Function or method call: `callee(args)`. -/ + | call (callee : RustExpr) (args : Array RustExpr) + /-- Indexed access: `arr[idx]`. -/ + | index (arr : RustExpr) (idx : RustExpr) + /-- Field access: `e.field`. -/ + | field (e : RustExpr) (name : String) + /-- Binary operator: `a op b`. The formatter parenthesises. -/ + | binop (op : String) (a b : RustExpr) + /-- `*e`. -/ + | deref (e : RustExpr) + /-- `&e`. -/ + | ref (e : RustExpr) + /-- `vec![...]`, `[...]`, etc. — `macro!(args)`. -/ + | macroCall (name : String) (args : Array RustExpr) + /-- A Rust array literal: `[a, b, c]`. -/ + | arrayLit (elems : Array RustExpr) + /-- A labeled block expression: `'label: { stmts }`. Used by + MatchContinue: case bodies `break 'label vec![...]` to bubble + yielded values, the labeled block as a whole evaluates to the + yielded `Vec`. -/ + | labeledBlock (label : String) (stmts : Array RustStmt) + deriving Inhabited + +inductive RustStmt where + /-- `let [mut] name [: ty] = expr;` -/ + | letStmt (isMut : Bool) (name : String) (ty : Option String) (val : RustExpr) + /-- `*target += val;` (used for multiplicity bumps). -/ + | addAssign (target : RustExpr) (val : RustExpr) + /-- `expr;` -/ + | exprStmt (e : RustExpr) + /-- `return expr;` -/ + | returnStmt (e : RustExpr) + /-- `if cond { thenStmts } else { elseStmts? }` -/ + | ifStmt (cond : RustExpr) (thenStmts : Array RustStmt) (elseStmts : Option (Array RustStmt)) + /-- `if let Some(binding) = scrut { thenStmts } else { elseStmts }` — + the shape used for Aiur's memoization cache checks. -/ + | ifLetSome (binding : String) (scrut : RustExpr) + (thenStmts : Array RustStmt) (elseStmts : Array RustStmt) + /-- `match scrut { pats... }` -/ + | matchStmt (scrut : RustExpr) (arms : Array MatchArm) + /-- A nested block `{ stmts }` for scoping. -/ + | block (stmts : Array RustStmt) + /-- `break 'label expr;` — yield a value out of an enclosing + labeledBlock. -/ + | breakWith (label : String) (e : RustExpr) + deriving Inhabited + +inductive MatchPat where + | litU64 (n : Nat) + | wildcard + deriving Inhabited + +structure MatchArm where + pat : MatchPat + body : Array RustStmt + deriving Inhabited + +end + +/-- A generated top-level item. -/ +inductive RustItem where + /-- A constant: `const NAME: usize = value;` -/ + | constUsize (name : String) (value : Nat) + /-- A function. -/ + | function (name : String) (params : Array (String × String)) + (returnTy : String) (body : Array RustStmt) + /-- Raw text (prelude, enum decls, etc.). -/ + | raw (text : String) + deriving Inhabited + +/-! ## Pretty printer + + Indentation: 2 spaces per nesting level. Expressions render on one + line; statements get their own line. Match arms are one block each. +-/ + +@[inline] def indent (n : Nat) : String := + String.ofList (List.replicate (n * 2) ' ') + +def MatchPat.toStr : MatchPat → String + | .litU64 n => s!"{n}u64" + | .wildcard => "_" + +mutual + +partial def RustExpr.toStr : RustExpr → String + | .var n => n + | .lit t => t + | .path segs => "::".intercalate segs.toList + | .call c args => + let argList := ", ".intercalate (args.toList.map RustExpr.toStr) + s!"{c.toStr}({argList})" + | .index a i => s!"{a.toStr}[{i.toStr}]" + | .field e n => s!"{e.toStr}.{n}" + | .binop op a b => s!"({a.toStr} {op} {b.toStr})" + | .deref e => s!"*{e.toStr}" + | .ref e => s!"&{e.toStr}" + | .macroCall n args => + let argList := ", ".intercalate (args.toList.map RustExpr.toStr) + s!"{n}!({argList})" + | .arrayLit elems => + let lb := "[" + let rb := "]" + let elemList := ", ".intercalate (elems.toList.map RustExpr.toStr) + s!"{lb}{elemList}{rb}" + | .labeledBlock label stmts => + -- One-line approximation. Aiur case bodies are short enough. + let body := stmts.toList.map (RustStmt.toStr 0) |>.foldl (· ++ ·) "" + let lbrace := "{" + let rbrace := "}" + s!"'{label}: {lbrace} {body} {rbrace}" + +partial def RustStmt.toStr (d : Nat) : RustStmt → String + | .letStmt isMut name ty val => + let mutStr := if isMut then "mut " else "" + let tyStr := match ty with | some t => s!": {t}" | none => "" + s!"{indent d}let {mutStr}{name}{tyStr} = {val.toStr};\n" + | .addAssign target val => + s!"{indent d}{target.toStr} += {val.toStr};\n" + | .exprStmt e => s!"{indent d}{e.toStr};\n" + | .returnStmt e => s!"{indent d}return {e.toStr};\n" + | .ifLetSome binding scrut thenStmts elseStmts => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}if let Some({binding}) = {scrut.toStr} {lbrace}\n" + o := o ++ stmtsToStr (d+1) thenStmts + o := o ++ s!"{indent d}{rbrace} else {lbrace}\n" + o := o ++ stmtsToStr (d+1) elseStmts + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .ifStmt cond thenStmts elseStmts? => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}if {cond.toStr} {lbrace}\n" + o := o ++ stmtsToStr (d+1) thenStmts + match elseStmts? with + | some elseStmts => + o := o ++ s!"{indent d}{rbrace} else {lbrace}\n" + o := o ++ stmtsToStr (d+1) elseStmts + o := o ++ s!"{indent d}{rbrace}\n" + | none => + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .matchStmt scrut arms => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}match {scrut.toStr} {lbrace}\n" + for arm in arms do + o := o ++ s!"{indent (d+1)}{arm.pat.toStr} => {lbrace}\n" + o := o ++ stmtsToStr (d+2) arm.body + o := o ++ s!"{indent (d+1)}{rbrace},\n" + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .block stmts => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}{lbrace}\n" + o := o ++ stmtsToStr (d+1) stmts + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .breakWith label e => + s!"{indent d}break '{label} {e.toStr};\n" + +partial def stmtsToStr (d : Nat) (stmts : Array RustStmt) : String := Id.run do + let mut o := "" + for s in stmts do + o := o ++ s.toStr d + o + +end + +def RustItem.toStr : RustItem → String + | .constUsize n v => s!"const {n}: usize = {v};\n" + | .raw text => text + | .function name params returnTy body => Id.run do + let lbrace := "{" + let rbrace := "}" + let paramList := ",\n ".intercalate + (params.toList.map (fun (n, t) => s!"{n}: {t}")) + let mut o := s!"fn {name}(\n {paramList},\n) -> {returnTy} {lbrace}\n" + o := o ++ stmtsToStr 1 body + o := o ++ s!"{rbrace}\n\n" + return o + +/-! ## IR helper constructors -/ + +def gZero : RustExpr := .path #["G", "ZERO"] +def gOne : RustExpr := .path #["G", "ONE"] +def gFromU64 (n : Nat) : RustExpr := .call (.path #["G", "from_u64"]) #[.lit (toString n)] +def gFromBool (cond : RustExpr) : RustExpr := .call (.path #["G", "from_bool"]) #[cond] +def gFromUsize (n : RustExpr) : RustExpr := .call (.path #["G", "from_usize"]) #[n] + +/-- Local variable for Aiur ValIdx `i` — `__v_{i}`. Replaces the + interpreter's `map[i]` Vec lookup. -/ +def valVar (i : Nat) : RustExpr := .var s!"__v_{i}" + +/-- Emit a single-G let-binding for the next ValIdx slot. -/ +def declVal (idx : Nat) (rhs : RustExpr) : RustStmt := + .letStmt false s!"__v_{idx}" (some "G") rhs + +/-- The `[G; n]` array literal of `valVar` for `is`. -/ +def argsAsArray (is : Array ValIdx) : RustExpr := + .arrayLit (is.map valVar) + +/-- `record.function_queries[idx]` access. -/ +def funQueriesAt (idx : Nat) : RustExpr := + .index (.field (.var "record") "function_queries") (.lit (toString idx)) + +/-- `record.memory_queries.get_mut(&SIZE)?` chain — used by Store/Load. -/ +def memQueriesGetMut (size : Nat) : RustExpr := + .call (.field (.field (.var "record") "memory_queries") "get_mut") + #[.ref (.lit (toString size))] + +/-- `cond` Rust expression for `!unconstrained && !op_unconstrained` / + `!unconstrained` etc. We emit as `lit` to avoid building elaborate + AST for unary `!`. -/ +def litBool (b : Bool) : RustExpr := .lit (if b then "true" else "false") + +/-- `!unconstrained`. -/ +def notUnconstrained : RustExpr := .lit "!unconstrained" + +/-- `!unconstrained && !op_unconstrained` (or just `!unconstrained` when + `op_unconstrained == false`). -/ +def constrainedCond (opUn : Bool) : RustExpr := + if opUn then .lit "false" else notUnconstrained + +/-- `unconstrained || op_unconstrained` for callee propagation. -/ +def calleeUnconstrained (opUn : Bool) : RustExpr := + if opUn then .lit "true" else .var "unconstrained" + +/-! ## Op emission + + Each emitted Op mirrors `src/aiur/execute.rs`'s matching arm. The + interpreter's `map: Vec` is gone: every Aiur ValIdx becomes a + real Rust local `__v_{i}: G`. Per-op output counts decide how many + new locals each op allocates; the counter is threaded via + `EmitM`. + + Multi-output ops emit consecutive let-bindings; helpers that need + a Vec-shaped scratch (byte ops via `bytes{1,2}_execute`) build a + small local Vec inside a sub-block and read outputs back out as + G values. +-/ + +/-- How many ValIdx slots an Op consumes (i.e. how much it grows + Aiur's value-stack). MUST match `execute.rs`'s `map.push` / + `map.extend` totals exactly per arm — else local-variable names + drift from the bytecode's expected ValIdx layout and subsequent + ops index the wrong values. -/ +def Op.outputCount : Op → Nat + | .const _ => 1 + | .add _ _ | .sub _ _ | .mul _ _ | .eqZero _ => 1 + | .call _ _ outSize _ => outSize + | .store _ => 1 + | .load size _ => size + | .assertEq _ _ => 0 + | .ioGetInfo _ _ => 2 + | .ioSetInfo _ _ _ _ => 0 + | .ioRead _ _ len => len + | .ioWrite _ _ => 0 + | .u8BitDecomposition _ => 8 + | .u8ShiftLeft _ | .u8ShiftRight _ => 1 + | .u8Xor _ _ | .u8And _ _ | .u8Or _ _ | .u8LessThan _ _ => 1 + | .u8Mul _ _ => 2 + | .u8Add _ _ | .u8Sub _ _ => 2 + | .u8ChainRotr7 _ _ | .u8ChainRotr4 _ _ => 3 + | .u32LessThan _ _ => 1 + | .u8RangeCheck _ _ => 0 + | .unconstrainedBigUintDivMod _ _ => 2 + | .debug _ _ => 0 + +private def emitConst (out : Nat) (c : Aiur.G) : Array RustStmt := + #[declVal out (gFromU64 c.n)] + +private def emitBinop (out : Nat) (op : String) (a b : ValIdx) : Array RustStmt := + #[declVal out (.binop op (valVar a) (valVar b))] + +private def emitEqZero (out : Nat) (a : ValIdx) : Array RustStmt := + #[declVal out (gFromBool (.binop "==" (valVar a) gZero))] + +/-- `Op::Call`: mirror execute.rs lines 284-305 (caller) + 625-633 + (callee's Return inserts into `function_queries[fun_idx]`). On + cache hit: bump multiplicity if both sides constrained, extend map + with cached output. On miss: direct Rust call to the generated + callee. -/ +private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) + (outSize : Nat) (opUn : Bool) : Array RustStmt := Id.run do + -- Build the inner cache-check as a Rust block expression (raw lit). + -- Structured IR for if-let-as-expression would need a `blockExpr` + -- node; deferred until after parity testing validates the shape. + let argsStr : String := (argsAsArray args).toStr + let opUnStr : String := if opUn then "true" else "false" + let blockExpr : String := + s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++ + s!" let __cu = unconstrained || {opUnStr};" ++ + s!" if let Some(result) = record.function_queries[{callee}].get_mut(&__args[..]) \{" ++ + s!" if !unconstrained && !{opUnStr} \{ *result.multiplicity += G::ONE; }" ++ + s!" let __ret: [G; OUT_{callee}] = result.output.try_into().unwrap(); __ret" ++ + s!" } else \{ aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr) + ] + for k in [0 : outSize] do + stmts := stmts.push (declVal (out + k) (.index (.var "__r_arr") (.lit (toString k)))) + return stmts + +/-- `Op::Store`: mirror execute.rs lines 306-326. Insert hit/miss into + `record.memory_queries[size]`; output is the allocated/cached ptr. -/ +private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := + let size := values.size + let valsStr : String := (argsAsArray values).toStr + let blockExpr : String := + s!"\{ let __values: [G; {size}] = {valsStr};" ++ + s!" let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ + s!" if let Some(result) = __mq.get_mut(&__values[..]) \{" ++ + s!" if !unconstrained \{ *result.multiplicity += G::ONE; }" ++ + s!" result.output[0]" ++ + s!" } else \{" ++ + s!" let __ptr = G::from_usize(__mq.len());" ++ + s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }" + #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + +/-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer + index, bump multiplicity if constrained, splat `size` outputs. -/ +private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt := Id.run do + let blockExpr : String := + s!"\{ let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ + s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++ + s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++ + s!" let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++ + s!" if !unconstrained \{ *__mult += G::ONE; }" ++ + s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__loaded" (some s!"[G; {size}]") (.lit blockExpr) + ] + for k in [0 : size] do + stmts := stmts.push (declVal (out + k) (.index (.var "__loaded") (.lit (toString k)))) + return stmts + +/-- `Op::AssertEq`: mirror execute.rs lines 346-363. -/ +private def emitAssertEq (xs ys : Array ValIdx) : Array RustStmt := + if xs.size != ys.size then + #[.exprStmt (.lit s!"return Err(ExecError::AssertEqLengthMismatch \{ lhs: {xs.size}, rhs: {ys.size} })")] + else Id.run do + let mut stmts : Array RustStmt := #[] + for (x, y) in xs.zip ys do + stmts := stmts.push (.ifStmt + (.binop "!=" (valVar x) (valVar y)) + #[.exprStmt (.lit s!"return Err(ExecError::AssertEqMismatch \{ lhs: __v_{x}.as_canonical_u64(), rhs: __v_{y}.as_canonical_u64() })")] + none) + return stmts + +/-! ### IO ops -/ + +/-- `Op::IOGetInfo`: pushes 2 outputs (idx, len). -/ +private def emitIOGetInfo (out : Nat) (channel : ValIdx) (key : Array ValIdx) : + Array RustStmt := + let keyStr := (argsAsArray key).toStr + let blockIdxLen : String := + s!"\{ let __key: [G; {key.size}] = {keyStr};" ++ + s!" let __info = io_buffer.get_info(__v_{channel}, &__key[..])?;" ++ + s!" (G::from_usize(__info.idx), G::from_usize(__info.len)) }" + #[ + .letStmt false "__io_pair" (some "(G, G)") (.lit blockIdxLen), + declVal out (.field (.var "__io_pair") "0"), + declVal (out + 1) (.field (.var "__io_pair") "1") + ] + +/-- `Op::IOSetInfo`: 0 outputs; side-effects io_buffer. -/ +private def emitIOSetInfo (channel : ValIdx) (key : Array ValIdx) + (idx len : ValIdx) : Array RustStmt := + let keyStr := (argsAsArray key).toStr + let stmt : String := + s!"\{ let __key: [G; {key.size}] = {keyStr};" ++ + s!" let __idx = usize::try_from(__v_{idx}.as_canonical_u64()).ok().ok_or(ExecError::IndexTooLarge(__v_{idx}.as_canonical_u64()))?;" ++ + s!" let __len = usize::try_from(__v_{len}.as_canonical_u64()).ok().ok_or(ExecError::IndexTooLarge(__v_{len}.as_canonical_u64()))?;" ++ + s!" io_buffer.set_info(__v_{channel}, __key.to_vec(), __idx, __len)?; }" + #[.exprStmt (.lit stmt)] + +/-- `Op::IORead`: pushes `len` outputs (one G per byte). -/ +private def emitIORead (out : Nat) (channel : ValIdx) (idx : ValIdx) (len : Nat) : + Array RustStmt := Id.run do + let blockExpr : String := + s!"\{ let __idx_u64 = __v_{idx}.as_canonical_u64();" ++ + s!" let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?;" ++ + s!" let __data = io_buffer.read(__v_{channel}, __idx, {len})?;" ++ + s!" let __arr: [G; {len}] = __data[..{len}].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__io_read" (some s!"[G; {len}]") (.lit blockExpr) + ] + for k in [0 : len] do + stmts := stmts.push (declVal (out + k) (.index (.var "__io_read") (.lit (toString k)))) + return stmts + +/-- `Op::IOWrite`: 0 outputs; side-effects io_buffer. -/ +private def emitIOWrite (channel : ValIdx) (data : Array ValIdx) : Array RustStmt := + let dataIter : RustExpr := + .call (.field (.arrayLit (data.map valVar)) "into_iter") #[] + #[.exprStmt + (.call (.field (.var "io_buffer") "write") + #[valVar channel, dataIter])] + +/-! ### Byte ops + + All `U8*` ops are gated on `unconstrained`: in constrained mode + they go through `bytes{1,2}_execute` helpers (which update + `record.bytes{1,2}_queries`); in unconstrained mode they take a + pure arithmetic shortcut and skip the byte-chip queries. + + For codegen simplicity, the constrained path is emitted as a raw + helper call; the unconstrained shortcut is the pure variant of + the same op. The execute.rs interpreter does the same dispatch. +-/ + +/-- Bytes1 op with a single G output. The interpreter's + `bytes1_execute` extends `map` by 1 G; the unconstrained shortcut + is a single value. Generate a scratch Vec around the helper so the + output is captured into a local `__v_{out}`. -/ +private def emitU8Bytes1 (out : Nat) (gadgetOp : String) (byte : ValIdx) + (unconShortcut : String) (outCount : Nat) : Array RustStmt := Id.run do + -- `unconShortcut` example: `Bytes1::shift_left` (returns G). + -- BitDecomposition returns 8 Gs, so outCount = 8; others 1. + let unconExpr : String := + if outCount == 1 then s!"vec![{unconShortcut}(&__v_{byte})]" + else s!"{unconShortcut}(&__v_{byte}).to_vec()" + let blockExpr : String := + s!"\{ let mut __scratch: Vec = vec![__v_{byte}];" ++ + s!" if unconstrained \{ __scratch.extend({unconExpr}); }" ++ + s!" else \{ bytes1_execute(0, &Bytes1Op::{gadgetOp}, &mut __scratch, record); }" ++ + s!" let __arr: [G; {outCount}] = __scratch[1..].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b1_out" (some s!"[G; {outCount}]") (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.index (.var "__b1_out") (.lit (toString k)))) + return stmts + +/-- Bytes2 op with `outCount` G outputs. -/ +private def emitU8Bytes2 (out : Nat) (gadgetOp : String) (i j : ValIdx) + (unconShortcut : String) (outCount : Nat) : Array RustStmt := Id.run do + let unconExpr : String := + if outCount == 1 then s!"vec![Bytes2::{unconShortcut}(&__v_{i}, &__v_{j})]" + else + -- For ops that return tuples (mul → (lo, hi); chain → (o0,o1,o2)). + let tup := s!"Bytes2::{unconShortcut}(&__v_{i}, &__v_{j})" + let fields := (List.range outCount).map (fun k => s!"{tup}.{k}") |> String.intercalate ", " + s!"vec![{fields}]" + let blockExpr : String := + s!"\{ let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ + s!" if unconstrained \{ __scratch.extend({unconExpr}); }" ++ + s!" else \{ bytes2_execute(0, 1, &Bytes2Op::{gadgetOp}, &mut __scratch, record); }" ++ + s!" let __arr: [G; {outCount}] = __scratch[2..].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b2_out" (some s!"[G; {outCount}]") (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.index (.var "__b2_out") (.lit (toString k)))) + return stmts + +/-- `Op::U8Add`: gadget pushes 1 G (low byte) via bytes2_execute; carry + is computed natively. Two outputs total: `(low, carry)`. -/ +private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"\{ let (_, __carry) = Bytes2::add(&__v_{i}, &__v_{j});" ++ + s!" let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ + s!" if unconstrained \{ __scratch.push(Bytes2::add(&__v_{i}, &__v_{j}).0); }" ++ + s!" else \{ bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); }" ++ + s!" (__scratch[2], __carry) }" + #[ + .letStmt false "__b2_add" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__b2_add") "0"), + declVal (out + 1) (.field (.var "__b2_add") "1") + ] + +/-- `Op::U8Sub`: symmetric to U8Add. -/ +private def emitU8Sub (out : Nat) (i j : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"\{ let (_, __borrow) = Bytes2::sub(&__v_{i}, &__v_{j});" ++ + s!" let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ + s!" if unconstrained \{ __scratch.push(Bytes2::sub(&__v_{i}, &__v_{j}).0); }" ++ + s!" else \{ bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); }" ++ + s!" (__scratch[2], __borrow) }" + #[ + .letStmt false "__b2_sub" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__b2_sub") "0"), + declVal (out + 1) (.field (.var "__b2_sub") "1") + ] + +/-- `Op::U32LessThan`: mirror execute.rs lines 477-505. Pure + compare + 6-byte-pair range-check via + `bytes2_queries.bump_range_check` (constrained mode only). -/ +private def emitU32LessThan (out : Nat) (x y : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"\{ let __a_val = __v_{x}.as_canonical_u64();" ++ + s!" let __b_val = __v_{y}.as_canonical_u64();" ++ + s!" let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?;" ++ + s!" let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?;" ++ + s!" let __result = G::from_bool(__a_u32 < __b_u32);" ++ + s!" if !unconstrained \{" ++ + s!" let __x_bytes = __a_u32.to_le_bytes();" ++ + s!" let __z_bytes = __b_u32.to_le_bytes();" ++ + s!" let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1);" ++ + s!" let __y_bytes = __c_u32.to_le_bytes();" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]));" ++ + s!" } __result }" + #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + +/-- `Op::U8RangeCheck`: 0 outputs; pure range-check side effect. -/ +private def emitU8RangeCheck (i j : ValIdx) : Array RustStmt := + let stmt : String := + s!"if !unconstrained \{" ++ + s!" let __vi = __v_{i}; let __vj = __v_{j};" ++ + s!" let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64();" ++ + s!" if __bi >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bi)); }" ++ + s!" if __bj >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bj)); }" ++ + s!" record.bytes2_queries.bump_range_check(&__vi, &__vj);" ++ + s!" }" + #[.exprStmt (.lit stmt)] + +/-- `Op::UnconstrainedBigUintDivMod`: BigUint hint, 2 outputs + (q_ptr, r_ptr). Calls the extracted `unconstrained_big_uint_div_mod_helper` + which returns `(G, G)` directly. -/ +private def emitUncBigUintDivMod (out : Nat) (a b : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"unconstrained_big_uint_div_mod_helper(__v_{a}, __v_{b}, record)?" + #[ + .letStmt false "__bu_qr" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__bu_qr") "0"), + declVal (out + 1) (.field (.var "__bu_qr") "1") + ] + +/-- `Op::Debug`: 0 outputs; println side effect. Skipped for now. -/ +private def emitDebug : Array RustStmt := #[] + +/-- Top-level op dispatch. `out` = the first ValIdx for outputs; + callers must advance their counter by `Op.outputCount`. -/ +def emitOp (out : Nat) (op : Op) : Array RustStmt := + match op with + | .const c => emitConst out c + | .add a b => emitBinop out "+" a b + | .sub a b => emitBinop out "-" a b + | .mul a b => emitBinop out "*" a b + | .eqZero a => emitEqZero out a + | .call callee args outSz opUn => emitCall out callee args outSz opUn + | .store vs => emitStore out vs + | .load size ptr => emitLoad out size ptr + | .assertEq xs ys => emitAssertEq xs ys + | .ioGetInfo ch key => emitIOGetInfo out ch key + | .ioSetInfo ch key idx len => emitIOSetInfo ch key idx len + | .ioRead ch idx len => emitIORead out ch idx len + | .ioWrite ch data => emitIOWrite ch data + | .u8BitDecomposition b => emitU8Bytes1 out "BitDecomposition" b "Bytes1::bit_decompose" 8 + | .u8ShiftLeft b => emitU8Bytes1 out "ShiftLeft" b "Bytes1::shift_left" 1 + | .u8ShiftRight b => emitU8Bytes1 out "ShiftRight" b "Bytes1::shift_right" 1 + | .u8Xor i j => emitU8Bytes2 out "Xor" i j "xor" 1 + | .u8Mul i j => emitU8Bytes2 out "Mul" i j "mul" 2 + | .u8And i j => emitU8Bytes2 out "And" i j "and" 1 + | .u8Or i j => emitU8Bytes2 out "Or" i j "or" 1 + | .u8LessThan i j => emitU8Bytes2 out "LessThan" i j "less_than" 1 + | .u8ChainRotr7 i j => emitU8Bytes2 out "ChainRotr7" i j "chain_rotr7" 3 + | .u8ChainRotr4 i j => emitU8Bytes2 out "ChainRotr4" i j "chain_rotr4" 3 + | .u8Add i j => emitU8Add out i j + | .u8Sub i j => emitU8Sub out i j + | .u32LessThan a b => emitU32LessThan out a b + | .u8RangeCheck i j => emitU8RangeCheck i j + | .unconstrainedBigUintDivMod a b => emitUncBigUintDivMod out a b + | .debug _ _ => emitDebug + +/-! ## Ctrl emission -/ + +/-- Scan a Block for the first `Ctrl.return`'s arity. Aiur fn layouts + are fixed, so all Returns in a fn agree; we only need one. -/ +partial def findReturnArity (b : Block) : Option Nat := + ctrlArity b.ctrl +where + ctrlArity : Ctrl → Option Nat + | .return _ vals => some vals.size + | .yield _ _ => none + | .match _ cases dflt? => + let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) + match viaCases with + | some n => some n + | none => dflt?.bind findReturnArity + | .matchContinue _ cases dflt? _ _ _ cont => + let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) + let viaDflt := dflt?.bind findReturnArity + let viaCont := findReturnArity cont + viaCases <|> viaDflt <|> viaCont + +/-- Codegen state: `nextVal` is the next ValIdx slot to allocate for + op outputs (must match Aiur's value-stack growth exactly); + `nextLabel` is a fresh counter for unique `'__mc_N` labels in + nested `MatchContinue`s. -/ +structure EmitState where + nextVal : Nat + nextLabel : Nat + deriving Inhabited + +abbrev EmitM (α : Type) := StateM EmitState α + +@[inline] def freshLabel : EmitM String := do + let s ← get + set { s with nextLabel := s.nextLabel + 1 } + return s!"__mc_{s.nextLabel}" + +/-- Allocate `count` consecutive ValIdx slots and return the base. -/ +@[inline] def allocVals (count : Nat) : EmitM Nat := do + let s ← get + set { s with nextVal := s.nextVal + count } + return s.nextVal + +/-- Run `m` with the current `nextVal` snapshotted; on exit restore + `nextVal` to its value at entry. Used for `Match` / `MatchContinue` + case bodies, which logically execute from the SAME value-stack + snapshot that existed before the match dispatch. -/ +@[inline] def withSavedNextVal (m : EmitM α) : EmitM α := do + let saved := (← get).nextVal + let a ← m + modify ({ · with nextVal := saved }) + return a + +mutual + +/-- Emit a Block's stmts. `mcLabel?` is the label of the enclosing + `MatchContinue` (used by `Ctrl.yield` to `break` with values). + A Block whose Ctrl is `Return` does NOT bubble — it always emits + the outer fn's `return`. -/ +partial def emitBlock (funIdx : FunIdx) (mcLabel? : Option String) + (b : Block) : EmitM (Array RustStmt) := do + let mut stmts : Array RustStmt := #[] + for op in b.ops do + let outBase ← allocVals (Op.outputCount op) + stmts := stmts ++ emitOp outBase op + let ctrlStmts ← emitCtrl funIdx mcLabel? b.ctrl + return stmts ++ ctrlStmts + +partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) + (ctrl : Ctrl) : EmitM (Array RustStmt) := do + match ctrl with + | .return _ outs => + -- Mirror execute.rs Ctrl::Return: build the output array, insert + -- into function_queries (binding to the per-fn `inp` slice for + -- args), then Rust-return the array. Ignores `mcLabel?` because + -- Return exits the whole fn. + let outArr : RustStmt := + .letStmt false "__ret" (some s!"[G; OUT_{funIdx}]") + (.arrayLit (outs.map valVar)) + let insertCall : RustStmt := + .exprStmt (.call + (.field + (.index (.field (.var "record") "function_queries") + (.lit (toString funIdx))) + "insert") + #[.ref (.index (.var "inp") (.lit "..")), + .ref (.index (.var "__ret") (.lit "..")), + gFromBool (.lit "!unconstrained")]) + -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. + return #[outArr, insertCall, + .returnStmt (.call (.var "Ok") #[.var "__ret"])] + | .match valIdx cases dflt? => do + -- Each arm body executes from the SAME value-stack snapshot as + -- match entry. Snapshot nextVal per arm so per-arm allocations + -- don't leak to siblings. + let mut arms : Array MatchArm := #[] + for ⟨key, blk⟩ in cases do + let armBody ← withSavedNextVal (emitBlock funIdx mcLabel? blk) + arms := arms.push { pat := .litU64 key.n, body := armBody } + let dfltBody ← (match dflt? with + | some d => withSavedNextVal (emitBlock funIdx mcLabel? d) + | none => pure #[ + .returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "MatchNoCase"]) + #[.call (.field (valVar valIdx) "as_canonical_u64") #[]]])]) + arms := arms.push { pat := .wildcard, body := dfltBody } + return #[.matchStmt + (.call (.field (valVar valIdx) "as_canonical_u64") #[]) + arms] + | .matchContinue valIdx cases dflt? outputSize _shAux _shLk continuation => do + -- Snapshot the value-stack base for the case bodies; they all + -- run from this same snapshot. + -- + -- Generated shape (no `map`, only locals): + -- let __mc_out_N: [G; OUT_SIZE] = '__mc_N: { + -- match __v_{valIdx}.as_canonical_u64() { + -- K1 => { ... break '__mc_N [__v_a, __v_b, ...]; }, + -- ... + -- _ => { ... }, + -- } + -- }; + -- let __v_{base}: G = __mc_out_N[0]; + -- let __v_{base+1}: G = __mc_out_N[1]; + -- ... // outputSize values rebound at outer scope + -- /* continuation emitted with nextVal = base + outputSize */ + let label ← freshLabel + let mut arms : Array MatchArm := #[] + for ⟨key, blk⟩ in cases do + let armBody ← withSavedNextVal (emitBlock funIdx (some label) blk) + arms := arms.push { pat := .litU64 key.n, body := armBody } + let dfltBody ← (match dflt? with + | some d => withSavedNextVal (emitBlock funIdx (some label) d) + | none => pure #[ + .returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "MatchNoCase"]) + #[.call (.field (valVar valIdx) "as_canonical_u64") #[]]])]) + arms := arms.push { pat := .wildcard, body := dfltBody } + let matchStmt : RustStmt := + .matchStmt (.call (.field (valVar valIdx) "as_canonical_u64") #[]) arms + -- Reserve `outputSize` slots at outer scope for the yielded values. + let outBase ← allocVals outputSize + let yieldedLet : RustStmt := + .letStmt false s!"__mc_out_{label}" (some s!"[G; {outputSize}]") + (.labeledBlock label #[matchStmt]) + let mut splat : Array RustStmt := #[] + for k in [0 : outputSize] do + splat := splat.push + (declVal (outBase + k) + (.index (.var s!"__mc_out_{label}") (.lit (toString k)))) + let contStmts ← emitBlock funIdx mcLabel? continuation + return #[yieldedLet] ++ splat ++ contStmts + | .yield _ outs => + -- Yield: bubble values to the enclosing `MatchContinue`'s labeled + -- block via `break '__mc_N vec![...];`. Only valid inside a + -- MatchContinue case body, so `mcLabel?` MUST be set; if it isn't, + -- emit a panic so the failure is obvious during testing. + match mcLabel? with + | some label => + return #[.breakWith label (.arrayLit (outs.map valVar))] + | none => + return #[.exprStmt + (.lit "unreachable!(\"Ctrl::Yield outside of MatchContinue context\")")] + +end + +/-! ## Function & toplevel emission -/ + +def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do + let inSize := f.layout.inputSize + let outSize := (findReturnArity f.body).getD 0 + let inputSizeConst := RustItem.constUsize s!"INPUT_SIZE_{funIdx}" inSize + let inConst := RustItem.constUsize s!"IN_{funIdx}" inSize + let outConst := RustItem.constUsize s!"OUT_{funIdx}" outSize + -- Bind inputs as `__v_0..__v_{inSize-1}` so subsequent op outputs + -- can reference them by ValIdx. + let mut bindInputs : Array RustStmt := #[] + for i in [0 : inSize] do + bindInputs := bindInputs.push + (.letStmt false s!"__v_{i}" (some "G") (.index (.var "inp") (.lit (toString i)))) + -- nextVal starts at inSize (the next free ValIdx after the inputs). + let initState : EmitState := { nextVal := inSize, nextLabel := 0 } + let (bodyStmts, _) := (emitBlock funIdx none f.body).run initState + let body := bindInputs ++ bodyStmts + -- Wrap the whole body in `stacker::maybe_grow` so deep Aiur + -- recursion grows the stack on demand instead of overflowing. + -- Red zone 64KB / new stack 4MB — when the current thread has + -- <64KB of stack left, stacker allocates a fresh 4MB segment + -- and runs the closure there. Repeats as deep as the recursion + -- goes. + let lbrace := "{" + let rbrace := "}" + let bodyText : String := stmtsToStr 2 body + let fnText : String := + s!"fn aiur_fn_{funIdx}(\n" ++ + s!" inp: [G; IN_{funIdx}],\n" ++ + s!" record: &mut QueryRecord,\n" ++ + s!" io_buffer: &mut IOBuffer,\n" ++ + s!" unconstrained: bool,\n" ++ + s!") -> Result<[G; OUT_{funIdx}], ExecError> {lbrace}\n" ++ + s!" stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {lbrace}\n" ++ + bodyText ++ + s!" {rbrace})\n" ++ + s!"{rbrace}\n\n" + #[inputSizeConst, inConst, outConst, .raw fnText] + +def emitPrelude : RustItem := .raw + "// Auto-generated by Aiur codegen. Do not edit.\n\ + //\n\ + // Mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly.\n\ + //\n\ + // Skip rustfmt — this file is huge and the codegen lays it out\n\ + // for the compiler, not for humans.\n\ + #![cfg_attr(rustfmt, rustfmt::skip)]\n\ + #![allow(\n\ + \x20\x20unused_variables, unused_assignments, unused_mut, dead_code,\n\ + \x20\x20unused_parens, non_snake_case, clippy::all,\n\ + )]\n\ + \n\ + use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ + use crate::aiur::G;\n\ + use crate::aiur::execute::{\n\ + \x20\x20ExecError, IOBuffer, QueryRecord,\n\ + \x20\x20bytes1_execute, bytes2_execute, unconstrained_big_uint_div_mod_helper,\n\ + \x20\x20CodegenBytes1 as Bytes1, CodegenBytes1Op as Bytes1Op,\n\ + \x20\x20CodegenBytes2 as Bytes2, CodegenBytes2Op as Bytes2Op,\n\ + };\n\ + \n" + +/-- Build the dispatch entry point `pub fn execute_generated(...)` + that maps a `fun_idx` to the right `aiur_fn_N` invocation. Mirrors + the interpreter's `execute::execute` signature so callers (kernel + runner, tests) can swap it in. -/ +def emitDispatch (tl : Toplevel) : RustItem := Id.run do + let mut arms : Array MatchArm := #[] + for funIdx in [0 : tl.functions.size] do + let armBody : Array RustStmt := #[ + .letStmt false "__inp" (some s!"[G; IN_{funIdx}]") + (.lit "args.try_into().expect(\"input size mismatch\")"), + .letStmt false "__out" none + (.lit s!"aiur_fn_{funIdx}(__inp, record, io_buffer, false)?"), + .returnStmt (.call (.var "Ok") + #[.call (.field (.var "__out") "to_vec") #[]]) + ] + arms := arms.push { pat := .litU64 funIdx, body := armBody } + arms := arms.push { + pat := .wildcard, + body := #[.returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "InvalidFunIdx"]) #[.var "fun_idx"]])] + } + -- Emit raw text for the dispatch fn so we can prefix `pub(crate)` + -- without extending RustItem. The body is built via stmtsToStr at + -- the right indentation. + let body : Array RustStmt := #[.matchStmt (.lit "fun_idx as u64") arms] + let lbrace := "{" + let rbrace := "}" + .raw (s!"pub(crate) fn execute_generated(\n" ++ + s!" fun_idx: usize,\n" ++ + s!" args: &[G],\n" ++ + s!" record: &mut QueryRecord,\n" ++ + s!" io_buffer: &mut IOBuffer,\n" ++ + s!") -> Result, ExecError> {lbrace}\n" ++ + stmtsToStr 1 body ++ + s!"{rbrace}\n") + +/-- Emit Rust source for the whole `Bytecode.Toplevel`. -/ +def emit (tl : Toplevel) : String := Id.run do + let mut items : Array RustItem := #[emitPrelude] + for funIdx in [0 : tl.functions.size] do + items := items ++ emitFunction funIdx tl.functions[funIdx]! + items := items.push (emitDispatch tl) + let mut o := "" + for it in items do + o := o ++ it.toStr + o + +end Aiur.Codegen + +end diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 5f55d2b5..497c03b2 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -102,16 +102,18 @@ def emitStats (compiled : Aiur.CompiledToplevel) try Aiur.printStats stats finally let _ ← IO.setStdout old -/-- Run a single witness through the compiled Aiur bytecode. -/ +/-- Run a single witness through the codegen'd IxVM Rust kernel + (`Bytecode.Toplevel.executeIxVM`). The bytecode interpreter is + no longer reachable from `ix check`. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) (statsOut : Option String) (witness : IxVM.ClaimHarness.ClaimWitness) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" (← IO.getStdout).flush let funIdx := compiled.getFuncIdx witness.funcName |>.get! - match compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer with + match compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer with | .error e => - IO.eprintln s!"{label}: Aiur execution error: {e}" + IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" return 1 | .ok (_output, _ioBuffer, queryCounts) => if printStats then emitStats compiled queryCounts statsOut @@ -471,7 +473,7 @@ def checkCmd : Cli.Cmd := `[Cli| "Typecheck Lean / `.ixe` constants through the IxVM Aiur kernel" FLAGS: - interp; "Use the Aiur interpreter (richer per-execution error diagnostics) instead of the compiled bytecode runner." + interp; "Use the Aiur interpreter (richer per-execution error diagnostics) instead of the codegen'd IxVM Rust kernel." "keep-going"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean new file mode 100644 index 00000000..51e40b43 --- /dev/null +++ b/Ix/Cli/CodegenCmd.lean @@ -0,0 +1,60 @@ +/- + `ix codegen`: write the IxVM kernel as a Rust source file via the + Bytecode → Rust codegen pass. + + Output path is fixed at compile time: `src/ix/aiur_ixvm.rs`. The + generated file is the single destination; no flag overrides. + + Output: a Rust module body containing one `fn aiur_fn_N(...)` per + Aiur kernel function, plus per-fn `IN_N` / `OUT_N` / `INPUT_SIZE_N` + size constants and the dispatch entry `execute_generated`. + + Before integrating into the build pipeline: + 1. Generate code for a single small Aiur fn (e.g. `klimbs_add`). + 2. Drop the generated source into a Rust test crate. + 3. Run both backends (`execute_generated` vs the interpreter + `execute::execute`) on identical input. + 4. Diff the resulting `QueryRecord`. Any divergence ⇒ invalid + witnesses ⇒ proving fails hard. + + Only after parity is confirmed should this be wired into the main + ix build pipeline as a build-script step. +-/ +module +public import Cli +public import Ix.Aiur.Compiler +public import Ix.Aiur.Stages.Codegen +public import Ix.IxVM + +public section + +namespace Ix.Cli.CodegenCmd + +open Aiur + +/-- Fixed destination — compile-time constant, no CLI override. -/ +def codegenOutPath : String := "src/ix/aiur_ixvm.rs" + +def runCodegenCmd (_p : Cli.Parsed) : IO UInt32 := do + -- Compile the IxVM source to bytecode. + let src ← match IxVM.ixVM with + | .ok src => pure src + | .error e => IO.eprintln s!"IxVM source error: {repr e}"; return 1 + let compiled ← match src.compile with + | .ok c => pure c + | .error e => IO.eprintln s!"Aiur compile error: {e}"; return 1 + let rustSource := Aiur.Codegen.emit compiled.bytecode + IO.FS.writeFile codegenOutPath rustSource + IO.println s!"[codegen] wrote {rustSource.length} bytes to {codegenOutPath} \ + ({compiled.bytecode.functions.size} aiur fns)" + return 0 + +end Ix.Cli.CodegenCmd + +open Ix.Cli.CodegenCmd in +def codegenCmd : Cli.Cmd := `[Cli| + "codegen" VIA runCodegenCmd; + "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `src/ix/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces." +] + +end diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 5b1fb25a..135edb48 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -74,8 +74,11 @@ def proveOne (aiurSystem : Aiur.AiurSystem) IO.eprintln s!"{label}: entrypoint `{witness.funcName}` missing from compiled toplevel" return 1 let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + -- Native IxVM path: routes execution through the codegen'd Rust + -- kernel (`execute_generated`) instead of the bytecode interpreter. + -- Proof verification-compatible with the interpreter path. let (_aiurClaim, proof, _outIO) := - aiurSystem.prove friParameters funIdx witness.input witness.inputIOBuffer + aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) diff --git a/Main.lean b/Main.lean index e72ae1e8..b1ee08f4 100644 --- a/Main.lean +++ b/Main.lean @@ -1,6 +1,7 @@ --import Ix.Cli.StoreCmd import Ix.Cli.AddrOfCmd import Ix.Cli.CheckCmd +import Ix.Cli.CodegenCmd import Ix.Cli.CheckRsCmd import Ix.Cli.ClaimCmd import Ix.Cli.CompileCmd @@ -32,6 +33,7 @@ def ixCmd : Cli.Cmd := `[Cli| profileCmd; proveCmd; shardCmd; + codegenCmd; verifyCmd; addrOfCmd; ingressCmd; diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 11fc4df4..8c45cec2 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -16,12 +16,12 @@ use crate::{ pub struct QueryRecord { pub function_queries: Vec, pub memory_queries: FxIndexMap, - pub(crate) bytes1_queries: Bytes1Queries, - pub(crate) bytes2_queries: Bytes2Queries, + pub bytes1_queries: Bytes1Queries, + pub bytes2_queries: Bytes2Queries, } impl QueryRecord { - fn new(toplevel: &Toplevel) -> Self { + pub fn new(toplevel: &Toplevel) -> Self { let function_queries = toplevel .functions .iter() @@ -53,7 +53,7 @@ pub struct IOBuffer { impl IOBuffer { #[inline] - pub(crate) fn get_info( + pub fn get_info( &self, channel: G, key: &[G], @@ -74,7 +74,7 @@ impl IOBuffer { Ok(()) } #[inline] - pub(crate) fn read( + pub fn read( &self, channel: G, idx: usize, @@ -113,6 +113,9 @@ pub enum ExecError { InvalidIOKey, IOMappingAlreadySet, IOReadOutOfBounds { idx: usize, len: usize }, + /// Dispatched a `fun_idx` that the codegen'd kernel doesn't know. + /// Generated by `execute_generated` in `crate::ix::aiur_ixvm`. + InvalidFunIdx(usize), } impl std::fmt::Display for ExecError { @@ -150,6 +153,7 @@ impl std::fmt::Display for ExecError { Self::IOReadOutOfBounds { idx, len } => { write!(f, "IO read out of bounds: idx={idx}, len={len}") }, + Self::InvalidFunIdx(idx) => write!(f, "invalid fun_idx {idx}"), } } } @@ -655,7 +659,7 @@ impl Function { } } -fn bytes1_execute( +pub fn bytes1_execute( byte: usize, op: &Bytes1Op, map: &mut Vec, @@ -664,7 +668,7 @@ fn bytes1_execute( map.extend(Bytes1.execute(op, &[map[byte]], record)); } -fn bytes2_execute( +pub fn bytes2_execute( i: usize, j: usize, op: &Bytes2Op, @@ -674,6 +678,45 @@ fn bytes2_execute( map.extend(Bytes2.execute(op, &[map[i], map[j]], record)); } +/// Re-exports for the codegen'd kernel (`ix::aiur_ixvm`). The generated +/// code names these as `aiur::execute::*`; we re-export them `pub` here +/// so an external `ix` crate can see them. +pub use crate::gadgets::bytes1::{ + Bytes1 as CodegenBytes1, Bytes1Op as CodegenBytes1Op, +}; +pub use crate::gadgets::bytes2::{ + Bytes2 as CodegenBytes2, Bytes2Op as CodegenBytes2Op, +}; + +/// Helper extracted for the codegen'd kernel: compute the unconstrained +/// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on +/// `record.memory_queries` as the inlined `Op::UnconstrainedBigUintDivMod` +/// arm in the interpreter. +pub fn unconstrained_big_uint_div_mod_helper( + a_ptr: G, + b_ptr: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + let a_limbs = read_klimbs_u64(&record.memory_queries, a_ptr) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let b_limbs = read_klimbs_u64(&record.memory_queries, b_ptr) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let a_big = klimbs_u64_to_biguint(&a_limbs); + let b_big = klimbs_u64_to_biguint(&b_limbs); + let (q_big, r_big) = if b_big == num_bigint::BigUint::ZERO { + (num_bigint::BigUint::ZERO, a_big.clone()) + } else { + (&a_big / &b_big, &a_big % &b_big) + }; + let q_limbs = biguint_to_klimbs_u64(&q_big); + let r_limbs = biguint_to_klimbs_u64(&r_big); + let q_ptr = build_klimbs_u64(&mut record.memory_queries, &q_limbs) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let r_ptr = build_klimbs_u64(&mut record.memory_queries, &r_limbs) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + Ok((q_ptr, r_ptr)) +} + /// Walk a `List` chain from `head_ptr` in `memory[10]`, returning the /// u64 limbs in head-first order. Each memory[10] entry is the standard Aiur /// tagged-enum layout: `[tag, byte0..byte7, next_ptr]`. `tag == 0` = Nil diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index cc83c5c9..b5f49c4c 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -25,9 +25,9 @@ const TRACE_WIDTH: usize = 3; const PREPROCESSED_TRACE_WIDTH: usize = 11; /// AIR implementer for arity 1 byte-related lookups. -pub(crate) struct Bytes1; +pub struct Bytes1; -pub(crate) enum Bytes1Op { +pub enum Bytes1Op { BitDecomposition, ShiftLeft, ShiftRight, @@ -205,7 +205,7 @@ impl AiurGadget for Bytes1 { } /// Accumulator of queries performed against `Bytes1`. -pub(crate) struct Bytes1Queries([[G; TRACE_WIDTH]; 256]); +pub struct Bytes1Queries([[G; TRACE_WIDTH]; 256]); impl Bytes1Queries { #[inline] @@ -233,18 +233,18 @@ impl Bytes1Queries { impl Bytes1 { #[inline] - pub(crate) fn bit_decompose(byte: &G) -> Vec { + pub fn bit_decompose(byte: &G) -> Vec { let byte_u64 = byte.as_canonical_u64(); (0..8).map(|i| G::from_bool((byte_u64 >> i) & 1 == 1)).collect() } #[inline] - pub(crate) fn shift_left(byte: &G) -> G { + pub fn shift_left(byte: &G) -> G { G::from_u64((byte.as_canonical_u64() << 1) & 255) } #[inline] - pub(crate) fn shift_right(byte: &G) -> G { + pub fn shift_right(byte: &G) -> G { G::from_u64(byte.as_canonical_u64() >> 1) } } diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index 949dcff8..15030b2b 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -48,9 +48,9 @@ const TRACE_WIDTH: usize = 10; const PREPROCESSED_TRACE_WIDTH: usize = 16; /// AIR implementer for arity 2 byte-related lookups. -pub(crate) struct Bytes2; +pub struct Bytes2; -pub(crate) enum Bytes2Op { +pub enum Bytes2Op { Xor, Add, Mul, @@ -422,7 +422,7 @@ impl AiurGadget for Bytes2 { } /// Accumulator of queries performed against `Bytes2`. -pub(crate) struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>); +pub struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>); impl Bytes2Queries { #[inline] @@ -454,7 +454,7 @@ impl Bytes2Queries { self.bump_multiplicity_for(i, j, 5) } - pub(crate) fn bump_range_check(&mut self, i: &G, j: &G) { + pub fn bump_range_check(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 6) } @@ -480,14 +480,14 @@ impl Bytes2Queries { impl Bytes2 { #[inline] - pub(crate) fn xor(i: &G, j: &G) -> G { + pub fn xor(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i ^ j) } #[inline] - pub(crate) fn add(i: &G, j: &G) -> (G, G) { + pub fn add(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (r, o) = i.overflowing_add(j); @@ -495,21 +495,21 @@ impl Bytes2 { } #[inline] - pub(crate) fn and(i: &G, j: &G) -> G { + pub fn and(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i & j) } #[inline] - pub(crate) fn or(i: &G, j: &G) -> G { + pub fn or(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i | j) } #[inline] - pub(crate) fn sub(i: &G, j: &G) -> (G, G) { + pub fn sub(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (r, u) = i.overflowing_sub(j); @@ -517,7 +517,7 @@ impl Bytes2 { } #[inline] - pub(crate) fn less_than(i: &G, j: &G) -> G { + pub fn less_than(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_bool(i < j) @@ -525,7 +525,7 @@ impl Bytes2 { /// `u8 * u8 -> (low byte, high byte)`. The product fits in 16 bits. #[inline] - pub(crate) fn mul(i: &G, j: &G) -> (G, G) { + pub fn mul(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let p = u16::from(i) * u16::from(j); @@ -540,7 +540,7 @@ impl Bytes2 { /// `[A0, A1+B2, B0, B1+A2]` for `A = chain_rotr7(b0,b1)`, /// `B = chain_rotr7(b2,b3)`. #[inline] - pub(crate) fn chain_rotr7_u8(i: u8, j: u8) -> (u8, u8, u8) { + pub fn chain_rotr7_u8(i: u8, j: u8) -> (u8, u8, u8) { ((i >> 7) + (j << 1), j >> 7, i << 1) } @@ -548,12 +548,12 @@ impl Bytes2 { /// of little-endian bytes. Given adjacent bytes `i`, `j`, returns /// `(i>>4 + j<<4, j>>4, i<<4)` where shifts are taken mod 256. #[inline] - pub(crate) fn chain_rotr4_u8(i: u8, j: u8) -> (u8, u8, u8) { + pub fn chain_rotr4_u8(i: u8, j: u8) -> (u8, u8, u8) { ((i >> 4) + (j << 4), j >> 4, i << 4) } #[inline] - pub(crate) fn chain_rotr7(i: &G, j: &G) -> (G, G, G) { + pub fn chain_rotr7(i: &G, j: &G) -> (G, G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (o0, o1, o2) = Self::chain_rotr7_u8(i, j); @@ -561,7 +561,7 @@ impl Bytes2 { } #[inline] - pub(crate) fn chain_rotr4(i: &G, j: &G) -> (G, G, G) { + pub fn chain_rotr4(i: &G, j: &G) -> (G, G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (o0, o1, o2) = Self::chain_rotr4_u8(i, j); diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 4ae1132d..a6b0f37d 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -12,8 +12,8 @@ pub struct QueryRef<'a> { /// Mutable view of one query entry: the output is fixed at insertion, /// only the multiplicity is bumped on memo hits. pub struct QueryRefMut<'a> { - pub(crate) output: &'a [G], - pub(crate) multiplicity: &'a mut G, + pub output: &'a [G], + pub multiplicity: &'a mut G, } fn hash_g_slice(key: &[G]) -> u64 { diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 8a8f1f1e..e4422dfa 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -16,7 +16,7 @@ use crate::{ G, bytecode::{FunIdx, Toplevel}, constraints::Constraints, - execute::IOBuffer, + execute::{ExecError, IOBuffer, QueryRecord}, function_channel, gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, @@ -174,6 +174,82 @@ impl AiurSystem { (claim, proof) } + /// IxVM-native prove: identical to `prove` except the execute step + /// is provided by the caller as `executor` (a closure that runs + /// the codegen'd Rust kernel `ix::aiur_ixvm_runner::execute_ixvm` + /// instead of the bytecode interpreter). Avoids a circular crate + /// dependency: `aiur` doesn't know about `ix`; `ix` (or its + /// downstream `ffi`) injects the executor. + /// + /// QueryRecord shape + witness construction + claim layout + proof + /// generation are all unchanged — the proof produced here is + /// verification-compatible with one produced by `prove`. + #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_ixvm")] + pub fn prove_ixvm( + &self, + fri_parameters: FriParameters, + fun_idx: FunIdx, + input: &[G], + io_buffer: &mut IOBuffer, + executor: F, + ) -> (Vec, Proof) + where + F: FnOnce( + &Toplevel, + FunIdx, + Vec, + &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError>, + { + tracing_texray::examine_current(); + let _g = tracing::info_span!("aiur/execute_ixvm").entered(); + let (query_record, output) = + executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) + .expect("IxVM-native Aiur execution failed during prove_ixvm"); + drop(_g); + + let _g = tracing::info_span!("aiur/witness").entered(); + let functions = + (0..self.toplevel.functions.len()).into_par_iter().filter_map(|idx| { + if self.toplevel.functions[idx].constrained { + Some(CircuitType::Function { idx }) + } else { + None + } + }); + let memories = self + .toplevel + .memory_sizes + .par_iter() + .map(|&width| CircuitType::Memory { width }); + let gadgets = [CircuitType::Bytes1, CircuitType::Bytes2].into_par_iter(); + let witness_data = functions + .chain(memories) + .chain(gadgets) + .map(|circuit_type| match circuit_type { + CircuitType::Function { idx } => { + self.toplevel.witness_data(idx, &query_record, io_buffer) + }, + CircuitType::Memory { width } => { + Memory::witness_data(width, &query_record) + }, + CircuitType::Bytes1 => Bytes1.witness_data(&query_record), + CircuitType::Bytes2 => Bytes2.witness_data(&query_record), + }) + .collect::>(); + drop(query_record); + let (traces, lookups) = witness_data.into_iter().unzip(); + let witness = SystemWitness { traces, lookups }; + drop(_g); + + let mut claim = vec![function_channel(), G::from_usize(fun_idx)]; + claim.extend(input); + claim.extend(output); + + let proof = self.system.prove(fri_parameters, &self.key, &claim, witness); + (claim, proof) + } + #[inline] pub fn verify( &self, diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml index aac4f212..f8ca5983 100644 --- a/crates/ffi/Cargo.toml +++ b/crates/ffi/Cargo.toml @@ -15,6 +15,7 @@ blake3 = { workspace = true } dashmap = { workspace = true, features = ["rayon"] } indexmap = { workspace = true, features = ["rayon"] } itertools = { workspace = true } +ix = { workspace = true } ix-common = { workspace = true } ix-compile = { workspace = true } ixon = { workspace = true } diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 7450a769..eb481a8f 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -169,6 +169,75 @@ extern "C" fn rs_aiur_toplevel_execute( LeanExcept::ok(result) } +/// `Bytecode.Toplevel.executeIxVM`: same shape as `rs_aiur_toplevel_execute`, +/// but routes execution through the codegen'd IxVM Rust kernel +/// (`ix::aiur_ixvm::execute_generated`) via the helper in +/// `ix::aiur_ixvm_runner::execute_ixvm`. The resulting +/// `QueryRecord` is byte-for-byte identical to the interpreter's +/// (modulo standing codegen parity invariant). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_execute_ixvm( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + args: LeanArray>, + io_data_arr: LeanArray>, + io_map_arr: LeanArray>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); + + let (query_record, output) = + match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, + fun_idx, + args.map(|x| lean_unbox_g(&x)), + &mut io_buffer, + ) { + Ok(pair) => pair, + Err(err) => return LeanExcept::error_string(&err.to_string()), + }; + + // Same query-count summarisation as `rs_aiur_toplevel_execute`. + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let lean_query_counts = { + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr + }; + + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + /// `AiurSystem.prove`: runs the prover and returns /// `Array G × Proof × Array G × Array (Array G × IOKeyInfo)` #[unsafe(no_mangle)] @@ -198,6 +267,41 @@ extern "C" fn rs_aiur_system_prove( result.into() } +/// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape +/// as `rs_aiur_system_prove`, but routes execution through the +/// codegen'd Rust kernel (`execute_generated`) via +/// `AiurSystem::prove_ixvm`. The resulting `Proof` is verification- +/// compatible with `rs_aiur_system_prove`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_prove_ixvm( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + args: LeanArray>, + io_data_arr: LeanArray>, + io_map_arr: LeanArray>, +) -> LeanOwned { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let args = args.map(|x| lean_unbox_g(&x)); + let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); + + let (claim, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &args, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io_tuple = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + result.into() +} + // ============================================================================= // Helpers // ============================================================================= diff --git a/crates/ix/Cargo.toml b/crates/ix/Cargo.toml new file mode 100644 index 00000000..f651fef9 --- /dev/null +++ b/crates/ix/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "ix" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aiur = { workspace = true } +ix-common = { workspace = true } +ixon = { workspace = true } +dashmap = { workspace = true, features = ["rayon"] } +multi-stark = { workspace = true } +num-bigint = { workspace = true } +rayon = { workspace = true } +rustc-hash = { workspace = true } +stacker = "0.1" + +[lints] +workspace = true diff --git a/crates/ix/src/aiur_ixvm.rs b/crates/ix/src/aiur_ixvm.rs new file mode 100644 index 00000000..06fcf7c9 --- /dev/null +++ b/crates/ix/src/aiur_ixvm.rs @@ -0,0 +1,68427 @@ +// Auto-generated by Aiur codegen. Do not edit. +// +// Mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly. +// +// Skip rustfmt — this file is huge and the codegen lays it out +// for the compiler, not for humans. +#![cfg_attr(rustfmt, rustfmt::skip)] +#![allow( + unused_variables, unused_assignments, unused_mut, dead_code, + unused_parens, non_snake_case, clippy::all, +)] + +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; +use aiur::G; +use aiur::execute::{ + ExecError, IOBuffer, QueryRecord, + bytes1_execute, bytes2_execute, unconstrained_big_uint_div_mod_helper, + CodegenBytes1 as Bytes1, CodegenBytes1Op as Bytes1Op, + CodegenBytes2 as Bytes2, CodegenBytes2Op as Bytes2Op, +}; + +const INPUT_SIZE_0: usize = 3; +const IN_0: usize = 3; +const OUT_0: usize = 1; +fn aiur_fn_0( + inp: [G; IN_0], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_0], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_0] = [__v_5]; + record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(1); + let __v_4: G = (__v_1 + __v_3); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_2 - __v_5); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; + let __v_8: G = __io_read[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_0] = [__v_10]; + record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_1: usize = 8; +const IN_1: usize = 8; +const OUT_1: usize = 1; +fn aiur_fn_1( + inp: [G; IN_1], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_1], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(3); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(3); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_2: usize = 8; +const IN_2: usize = 8; +const OUT_2: usize = 1; +fn aiur_fn_2( + inp: [G; IN_2], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_2], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_2] = [__v_8]; + record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_3: usize = 8; +const IN_3: usize = 8; +const OUT_3: usize = 4; +fn aiur_fn_3( + inp: [G; IN_3], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_3], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_8: G = __b2_add.0; + let __v_9: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_9); let mut __scratch: Vec = vec![__v_10, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __v_14: G = (__v_11 + __v_13); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_15: G = __b2_add.0; + let __v_16: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_15, &__v_14); let mut __scratch: Vec = vec![__v_15, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_15, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __v_19: G = (__v_16 + __v_18); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_20, &__v_19); let mut __scratch: Vec = vec![__v_20, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_20, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_22: G = __b2_add.0; + let __v_23: G = __b2_add.1; + let __ret: [G; OUT_3] = [__v_8, __v_12, __v_17, __v_22]; + record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_4: usize = 8; +const IN_4: usize = 8; +const OUT_4: usize = 4; +fn aiur_fn_4( + inp: [G; IN_4], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_4], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_8: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_9: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_10: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_11: G = __b2_out[0]; + let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11]; + record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_5: usize = 8; +const IN_5: usize = 8; +const OUT_5: usize = 4; +fn aiur_fn_5( + inp: [G; IN_5], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_5], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_8: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_9: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_2, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_10: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_3, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_11: G = __b2_out[0]; + let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; + record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_6: usize = 16; +const IN_6: usize = 16; +const OUT_6: usize = 1; +fn aiur_fn_6( + inp: [G; IN_6], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_6], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = (__v_0 - __v_8); + let __v_17: G = (__v_1 - __v_9); + let __v_18: G = (__v_2 - __v_10); + let __v_19: G = (__v_3 - __v_11); + let __v_20: G = (__v_4 - __v_12); + let __v_21: G = (__v_5 - __v_13); + let __v_22: G = (__v_6 - __v_14); + let __v_23: G = (__v_7 - __v_15); + match __v_16.as_canonical_u64() { + 0u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + match __v_19.as_canonical_u64() { + 0u64 => { + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + match __v_22.as_canonical_u64() { + 0u64 => { + match __v_23.as_canonical_u64() { + 0u64 => { + let __v_24: G = G::from_u64(1); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_7: usize = 16; +const IN_7: usize = 16; +const OUT_7: usize = 9; +fn aiur_fn_7( + inp: [G; IN_7], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_7], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_8); let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_16: G = __b2_add.0; + let __v_17: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_9); let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_18: G = __b2_add.0; + let __v_19: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_18, &__v_17); let mut __scratch: Vec = vec![__v_18, __v_17]; if unconstrained { __scratch.push(Bytes2::add(&__v_18, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __v_22: G = (__v_19 + __v_21); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_10); let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_10).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_23: G = __b2_add.0; + let __v_24: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_23, &__v_22); let mut __scratch: Vec = vec![__v_23, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_23, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_25: G = __b2_add.0; + let __v_26: G = __b2_add.1; + let __v_27: G = (__v_24 + __v_26); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_11); let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_28: G = __b2_add.0; + let __v_29: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_28, &__v_27); let mut __scratch: Vec = vec![__v_28, __v_27]; if unconstrained { __scratch.push(Bytes2::add(&__v_28, &__v_27).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_30: G = __b2_add.0; + let __v_31: G = __b2_add.1; + let __v_32: G = (__v_29 + __v_31); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_4, &__v_12); let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.push(Bytes2::add(&__v_4, &__v_12).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_33: G = __b2_add.0; + let __v_34: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_33, &__v_32); let mut __scratch: Vec = vec![__v_33, __v_32]; if unconstrained { __scratch.push(Bytes2::add(&__v_33, &__v_32).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_35: G = __b2_add.0; + let __v_36: G = __b2_add.1; + let __v_37: G = (__v_34 + __v_36); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_5, &__v_13); let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.push(Bytes2::add(&__v_5, &__v_13).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_38: G = __b2_add.0; + let __v_39: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_38, &__v_37); let mut __scratch: Vec = vec![__v_38, __v_37]; if unconstrained { __scratch.push(Bytes2::add(&__v_38, &__v_37).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_40: G = __b2_add.0; + let __v_41: G = __b2_add.1; + let __v_42: G = (__v_39 + __v_41); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_6, &__v_14); let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_6, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_43: G = __b2_add.0; + let __v_44: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_43, &__v_42); let mut __scratch: Vec = vec![__v_43, __v_42]; if unconstrained { __scratch.push(Bytes2::add(&__v_43, &__v_42).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_45: G = __b2_add.0; + let __v_46: G = __b2_add.1; + let __v_47: G = (__v_44 + __v_46); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_7, &__v_15); let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.push(Bytes2::add(&__v_7, &__v_15).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_48: G = __b2_add.0; + let __v_49: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_48, &__v_47); let mut __scratch: Vec = vec![__v_48, __v_47]; if unconstrained { __scratch.push(Bytes2::add(&__v_48, &__v_47).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_50: G = __b2_add.0; + let __v_51: G = __b2_add.1; + let __v_52: G = (__v_49 + __v_51); + let __ret: [G; OUT_7] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_8: usize = 16; +const IN_8: usize = 16; +const OUT_8: usize = 8; +fn aiur_fn_8( + inp: [G; IN_8], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_8], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __v_23: G = __r_arr[6]; + let __v_24: G = __r_arr[7]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __v_29: G = __r_arr[4]; + let __v_30: G = __r_arr[5]; + let __v_31: G = __r_arr[6]; + let __v_32: G = __r_arr[7]; + let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = result.output.try_into().unwrap(); __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = __r_arr[6]; + let __v_40: G = __r_arr[7]; + let __ret: [G; OUT_8] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; + record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_9: usize = 2; +const IN_9: usize = 2; +const OUT_9: usize = 1; +fn aiur_fn_9( + inp: [G; IN_9], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_9], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_9] = [__v_2]; + record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_9] = [__v_2]; + record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_9] = [__v_2]; + record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_10: usize = 8; +const IN_10: usize = 8; +const OUT_10: usize = 8; +fn aiur_fn_10( + inp: [G; IN_10], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_10], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 255u64 => { + match __v_1.as_canonical_u64() { + 255u64 => { + match __v_2.as_canonical_u64() { + 255u64 => { + match __v_3.as_canonical_u64() { + 255u64 => { + match __v_4.as_canonical_u64() { + 255u64 => { + match __v_5.as_canonical_u64() { + 255u64 => { + match __v_6.as_canonical_u64() { + 255u64 => { + match __v_7.as_canonical_u64() { + 255u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_7 + __v_15); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_6 + __v_14); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_5 + __v_13); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_4 + __v_12); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 + __v_11); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 + __v_9); + let __ret: [G; OUT_10] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_0 + __v_8); + let __ret: [G; OUT_10] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_11: usize = 10; +const IN_11: usize = 10; +const OUT_11: usize = 8; +fn aiur_fn_11( + inp: [G; IN_11], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_11], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_7, &__v_9); let mut __scratch: Vec = vec![__v_7, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_7, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_6, &__v_8); let mut __scratch: Vec = vec![__v_6, __v_8]; if unconstrained { __scratch.push(Bytes2::add(&__v_6, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_12, &__v_11); let mut __scratch: Vec = vec![__v_12, __v_11]; if unconstrained { __scratch.push(Bytes2::add(&__v_12, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_14: G = __b2_add.0; + let __v_15: G = __b2_add.1; + let __v_16: G = (__v_13 + __v_15); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_5, &__v_16); let mut __scratch: Vec = vec![__v_5, __v_16]; if unconstrained { __scratch.push(Bytes2::add(&__v_5, &__v_16).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_4, &__v_18); let mut __scratch: Vec = vec![__v_4, __v_18]; if unconstrained { __scratch.push(Bytes2::add(&__v_4, &__v_18).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_19: G = __b2_add.0; + let __v_20: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_20); let mut __scratch: Vec = vec![__v_3, __v_20]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_20).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_21: G = __b2_add.0; + let __v_22: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_22); let mut __scratch: Vec = vec![__v_2, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_23: G = __b2_add.0; + let __v_24: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_24); let mut __scratch: Vec = vec![__v_1, __v_24]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_24).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_25: G = __b2_add.0; + let __v_26: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_26); let mut __scratch: Vec = vec![__v_0, __v_26]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_26).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_27: G = __b2_add.0; + let __v_28: G = __b2_add.1; + let __ret: [G; OUT_11] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10]; + record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_12: usize = 8; +const IN_12: usize = 8; +const OUT_12: usize = 4; +fn aiur_fn_12( + inp: [G; IN_12], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_12], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_8: G = __b2_add.0; + let __v_9: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_9); let mut __scratch: Vec = vec![__v_10, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __v_14: G = (__v_11 + __v_13); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_15: G = __b2_add.0; + let __v_16: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_15, &__v_14); let mut __scratch: Vec = vec![__v_15, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_15, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __v_19: G = (__v_16 + __v_18); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_20, &__v_19); let mut __scratch: Vec = vec![__v_20, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_20, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_22: G = __b2_add.0; + let __v_23: G = __b2_add.1; + let __ret: [G; OUT_12] = [__v_22, __v_17, __v_12, __v_8]; + record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_13: usize = 8; +const IN_13: usize = 8; +const OUT_13: usize = 8; +fn aiur_fn_13( + inp: [G; IN_13], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_13], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(255); + let __v_13: G = G::from_u64(255); + let __v_14: G = G::from_u64(255); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_7 - __v_15); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(255); + let __v_13: G = G::from_u64(255); + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_6 - __v_14); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(255); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_5 - __v_13); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_4 - __v_12); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 - __v_11); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 - __v_10); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 - __v_9); + let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_0 - __v_8); + let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_14: usize = 8; +const IN_14: usize = 8; +const OUT_14: usize = 1; +fn aiur_fn_14( + inp: [G; IN_14], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_14], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = G::from_u64(0); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(256); + let __v_10: G = (__v_9 * __v_1); + let __v_11: G = G::from_u64(65536); + let __v_12: G = (__v_11 * __v_2); + let __v_13: G = G::from_u64(16777216); + let __v_14: G = (__v_13 * __v_3); + let __v_15: G = G::from_u64(4294967296); + let __v_16: G = (__v_15 * __v_4); + let __v_17: G = G::from_u64(1099511627776); + let __v_18: G = (__v_17 * __v_5); + let __v_19: G = G::from_u64(281474976710656); + let __v_20: G = (__v_19 * __v_6); + let __v_21: G = (__v_18 + __v_20); + let __v_22: G = (__v_16 + __v_21); + let __v_23: G = (__v_14 + __v_22); + let __v_24: G = (__v_12 + __v_23); + let __v_25: G = (__v_10 + __v_24); + let __v_26: G = (__v_0 + __v_25); + let __ret: [G; OUT_14] = [__v_26]; + record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_15: usize = 0; +const IN_15: usize = 0; +const OUT_15: usize = 32; +fn aiur_fn_15( + inp: [G; IN_15], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_15], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_1]; let __info = io_buffer.get_info(__v_0, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_2: G = __io_pair.0; + let __v_3: G = __io_pair.1; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = __r_arr[6]; + let __v_13: G = __r_arr[7]; + let __v_14: G = __r_arr[8]; + let __v_15: G = __r_arr[9]; + let __v_16: G = __r_arr[10]; + let __v_17: G = __r_arr[11]; + let __v_18: G = __r_arr[12]; + let __v_19: G = __r_arr[13]; + let __v_20: G = __r_arr[14]; + let __v_21: G = __r_arr[15]; + let __v_22: G = __r_arr[16]; + let __v_23: G = __r_arr[17]; + let __v_24: G = __r_arr[18]; + let __v_25: G = __r_arr[19]; + let __v_26: G = __r_arr[20]; + let __v_27: G = __r_arr[21]; + let __v_28: G = __r_arr[22]; + let __v_29: G = __r_arr[23]; + let __v_30: G = __r_arr[24]; + let __v_31: G = __r_arr[25]; + let __v_32: G = __r_arr[26]; + let __v_33: G = __r_arr[27]; + let __v_34: G = __r_arr[28]; + let __v_35: G = __r_arr[29]; + let __v_36: G = __r_arr[30]; + let __v_37: G = __r_arr[31]; + let __ret: [G; OUT_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_16: usize = 1; +const IN_16: usize = 1; +const OUT_16: usize = 1; +fn aiur_fn_16( + inp: [G; IN_16], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_16], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = (__v_0 - __v_1); + let __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = __r_arr[3]; + let __v_12: G = __r_arr[4]; + let __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_40: G = G::from_u64(0); + let __ret: [G; OUT_16] = [__v_40]; + record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = result.output.try_into().unwrap(); __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __ret: [G; OUT_16] = [__v_40]; + record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_17: usize = 1; +const IN_17: usize = 1; +const OUT_17: usize = 32; +fn aiur_fn_17( + inp: [G; IN_17], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_17], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(103); + let __v_2: G = G::from_u64(230); + let __v_3: G = G::from_u64(9); + let __v_4: G = G::from_u64(106); + let __v_5: G = G::from_u64(133); + let __v_6: G = G::from_u64(174); + let __v_7: G = G::from_u64(103); + let __v_8: G = G::from_u64(187); + let __v_9: G = G::from_u64(114); + let __v_10: G = G::from_u64(243); + let __v_11: G = G::from_u64(110); + let __v_12: G = G::from_u64(60); + let __v_13: G = G::from_u64(58); + let __v_14: G = G::from_u64(245); + let __v_15: G = G::from_u64(79); + let __v_16: G = G::from_u64(165); + let __v_17: G = G::from_u64(127); + let __v_18: G = G::from_u64(82); + let __v_19: G = G::from_u64(14); + let __v_20: G = G::from_u64(81); + let __v_21: G = G::from_u64(140); + let __v_22: G = G::from_u64(104); + let __v_23: G = G::from_u64(5); + let __v_24: G = G::from_u64(155); + let __v_25: G = G::from_u64(171); + let __v_26: G = G::from_u64(217); + let __v_27: G = G::from_u64(131); + let __v_28: G = G::from_u64(31); + let __v_29: G = G::from_u64(25); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(224); + let __v_32: G = G::from_u64(91); + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = G::from_u64(1); + let __v_49: G = G::from_u64(1); + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + let __v_55: G = __loaded[3]; + let __v_56: G = __loaded[4]; + let __v_57: G = __loaded[5]; + let __v_58: G = __loaded[6]; + let __v_59: G = __loaded[7]; + let __v_60: G = __loaded[8]; + let __v_61: G = __loaded[9]; + let __v_62: G = __loaded[10]; + let __v_63: G = __loaded[11]; + let __v_64: G = __loaded[12]; + let __v_65: G = __loaded[13]; + let __v_66: G = __loaded[14]; + let __v_67: G = __loaded[15]; + let __v_68: G = __loaded[16]; + let __v_69: G = __loaded[17]; + let __v_70: G = __loaded[18]; + let __v_71: G = __loaded[19]; + let __v_72: G = __loaded[20]; + let __v_73: G = __loaded[21]; + let __v_74: G = __loaded[22]; + let __v_75: G = __loaded[23]; + let __v_76: G = __loaded[24]; + let __v_77: G = __loaded[25]; + let __v_78: G = __loaded[26]; + let __v_79: G = __loaded[27]; + let __v_80: G = __loaded[28]; + let __v_81: G = __loaded[29]; + let __v_82: G = __loaded[30]; + let __v_83: G = __loaded[31]; + let __v_84: G = __loaded[32]; + let __v_85: G = __loaded[33]; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __v_86: G = __r_arr[0]; + let __v_87: G = __r_arr[1]; + let __v_88: G = __r_arr[2]; + let __v_89: G = __r_arr[3]; + let __v_90: G = __r_arr[4]; + let __v_91: G = __r_arr[5]; + let __v_92: G = __r_arr[6]; + let __v_93: G = __r_arr[7]; + let __v_94: G = __r_arr[8]; + let __v_95: G = __r_arr[9]; + let __v_96: G = __r_arr[10]; + let __v_97: G = __r_arr[11]; + let __v_98: G = __r_arr[12]; + let __v_99: G = __r_arr[13]; + let __v_100: G = __r_arr[14]; + let __v_101: G = __r_arr[15]; + let __v_102: G = __r_arr[16]; + let __v_103: G = __r_arr[17]; + let __v_104: G = __r_arr[18]; + let __v_105: G = __r_arr[19]; + let __v_106: G = __r_arr[20]; + let __v_107: G = __r_arr[21]; + let __v_108: G = __r_arr[22]; + let __v_109: G = __r_arr[23]; + let __v_110: G = __r_arr[24]; + let __v_111: G = __r_arr[25]; + let __v_112: G = __r_arr[26]; + let __v_113: G = __r_arr[27]; + let __v_114: G = __r_arr[28]; + let __v_115: G = __r_arr[29]; + let __v_116: G = __r_arr[30]; + let __v_117: G = __r_arr[31]; + let __ret: [G; OUT_17] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; + record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_18: usize = 1; +const IN_18: usize = 1; +const OUT_18: usize = 32; +fn aiur_fn_18( + inp: [G; IN_18], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_18], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + let __v_11: G = __r_arr[10]; + let __v_12: G = __r_arr[11]; + let __v_13: G = __r_arr[12]; + let __v_14: G = __r_arr[13]; + let __v_15: G = __r_arr[14]; + let __v_16: G = __r_arr[15]; + let __v_17: G = __r_arr[16]; + let __v_18: G = __r_arr[17]; + let __v_19: G = __r_arr[18]; + let __v_20: G = __r_arr[19]; + let __v_21: G = __r_arr[20]; + let __v_22: G = __r_arr[21]; + let __v_23: G = __r_arr[22]; + let __v_24: G = __r_arr[23]; + let __v_25: G = __r_arr[24]; + let __v_26: G = __r_arr[25]; + let __v_27: G = __r_arr[26]; + let __v_28: G = __r_arr[27]; + let __v_29: G = __r_arr[28]; + let __v_30: G = __r_arr[29]; + let __v_31: G = __r_arr[30]; + let __v_32: G = __r_arr[31]; + let __ret: [G; OUT_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_19: usize = 33; +const IN_19: usize = 33; +const OUT_19: usize = 0; +fn aiur_fn_19( + inp: [G; IN_19], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_19], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = result.output.try_into().unwrap(); __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = __r_arr[6]; + let __v_40: G = __r_arr[7]; + let __v_41: G = __r_arr[8]; + let __v_42: G = __r_arr[9]; + let __v_43: G = __r_arr[10]; + let __v_44: G = __r_arr[11]; + let __v_45: G = __r_arr[12]; + let __v_46: G = __r_arr[13]; + let __v_47: G = __r_arr[14]; + let __v_48: G = __r_arr[15]; + let __v_49: G = __r_arr[16]; + let __v_50: G = __r_arr[17]; + let __v_51: G = __r_arr[18]; + let __v_52: G = __r_arr[19]; + let __v_53: G = __r_arr[20]; + let __v_54: G = __r_arr[21]; + let __v_55: G = __r_arr[22]; + let __v_56: G = __r_arr[23]; + let __v_57: G = __r_arr[24]; + let __v_58: G = __r_arr[25]; + let __v_59: G = __r_arr[26]; + let __v_60: G = __r_arr[27]; + let __v_61: G = __r_arr[28]; + let __v_62: G = __r_arr[29]; + let __v_63: G = __r_arr[30]; + let __v_64: G = __r_arr[31]; + if (__v_33 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64() }); + } + if (__v_34 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + if (__v_35 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_3.as_canonical_u64() }); + } + if (__v_36 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + if (__v_37 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + if (__v_38 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + if (__v_39 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + if (__v_40 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + if (__v_41 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_42 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_43 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_44 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_45 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_46 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_47 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_48 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_49 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_50 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + if (__v_51 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + if (__v_52 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + if (__v_53 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + if (__v_54 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + if (__v_55 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + if (__v_56 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_24.as_canonical_u64() }); + } + if (__v_57 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); + } + if (__v_58 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + if (__v_59 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_27.as_canonical_u64() }); + } + if (__v_60 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_28.as_canonical_u64() }); + } + if (__v_61 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + if (__v_62 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_30.as_canonical_u64() }); + } + if (__v_63 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_31.as_canonical_u64() }); + } + if (__v_64 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __ret: [G; OUT_19] = []; + record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_20: usize = 1; +const IN_20: usize = 1; +const OUT_20: usize = 1; +fn aiur_fn_20( + inp: [G; IN_20], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_20], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = result.output.try_into().unwrap(); __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + let __v_11: G = __r_arr[10]; + let __v_12: G = __r_arr[11]; + let __v_13: G = __r_arr[12]; + let __v_14: G = __r_arr[13]; + let __v_15: G = __r_arr[14]; + let __v_16: G = __r_arr[15]; + let __v_17: G = __r_arr[16]; + let __v_18: G = __r_arr[17]; + let __v_19: G = __r_arr[18]; + let __v_20: G = __r_arr[19]; + let __v_21: G = __r_arr[20]; + let __v_22: G = __r_arr[21]; + let __v_23: G = __r_arr[22]; + let __v_24: G = __r_arr[23]; + let __v_25: G = __r_arr[24]; + let __v_26: G = __r_arr[25]; + let __v_27: G = __r_arr[26]; + let __v_28: G = __r_arr[27]; + let __v_29: G = __r_arr[28]; + let __v_30: G = __r_arr[29]; + let __v_31: G = __r_arr[30]; + let __v_32: G = __r_arr[31]; + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_20] = [__v_33]; + record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_21: usize = 67; +const IN_21: usize = 67; +const OUT_21: usize = 67; +fn aiur_fn_21( + inp: [G; IN_21], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_21], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(1); + let __v_69: G = G::from_u64(1); + let __ret: [G; OUT_21] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_67: G = __loaded[0]; + let __v_68: G = __loaded[1]; + let __v_69: G = __loaded[2]; + let __v_70: G = __loaded[3]; + let __v_71: G = __loaded[4]; + let __v_72: G = __loaded[5]; + let __v_73: G = __loaded[6]; + let __v_74: G = __loaded[7]; + let __v_75: G = __loaded[8]; + let __v_76: G = __loaded[9]; + let __v_77: G = __loaded[10]; + let __v_78: G = __loaded[11]; + let __v_79: G = __loaded[12]; + let __v_80: G = __loaded[13]; + let __v_81: G = __loaded[14]; + let __v_82: G = __loaded[15]; + let __v_83: G = __loaded[16]; + let __v_84: G = __loaded[17]; + let __v_85: G = __loaded[18]; + let __v_86: G = __loaded[19]; + let __v_87: G = __loaded[20]; + let __v_88: G = __loaded[21]; + let __v_89: G = __loaded[22]; + let __v_90: G = __loaded[23]; + let __v_91: G = __loaded[24]; + let __v_92: G = __loaded[25]; + let __v_93: G = __loaded[26]; + let __v_94: G = __loaded[27]; + let __v_95: G = __loaded[28]; + let __v_96: G = __loaded[29]; + let __v_97: G = __loaded[30]; + let __v_98: G = __loaded[31]; + let __v_99: G = __loaded[32]; + let __v_100: G = __loaded[33]; + let __v_101: G = G::from_u64(0); + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_101]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = result.output.try_into().unwrap(); __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_102: G = __r_arr[0]; + let __v_103: G = __r_arr[1]; + let __v_104: G = __r_arr[2]; + let __v_105: G = __r_arr[3]; + let __v_106: G = __r_arr[4]; + let __v_107: G = __r_arr[5]; + let __v_108: G = __r_arr[6]; + let __v_109: G = __r_arr[7]; + let __v_110: G = __r_arr[8]; + let __v_111: G = __r_arr[9]; + let __v_112: G = __r_arr[10]; + let __v_113: G = __r_arr[11]; + let __v_114: G = __r_arr[12]; + let __v_115: G = __r_arr[13]; + let __v_116: G = __r_arr[14]; + let __v_117: G = __r_arr[15]; + let __v_118: G = __r_arr[16]; + let __v_119: G = __r_arr[17]; + let __v_120: G = __r_arr[18]; + let __v_121: G = __r_arr[19]; + let __v_122: G = __r_arr[20]; + let __v_123: G = __r_arr[21]; + let __v_124: G = __r_arr[22]; + let __v_125: G = __r_arr[23]; + let __v_126: G = __r_arr[24]; + let __v_127: G = __r_arr[25]; + let __v_128: G = __r_arr[26]; + let __v_129: G = __r_arr[27]; + let __v_130: G = __r_arr[28]; + let __v_131: G = __r_arr[29]; + let __v_132: G = __r_arr[30]; + let __v_133: G = __r_arr[31]; + let __v_134: G = __r_arr[32]; + let __v_135: G = __r_arr[33]; + let __v_136: G = __r_arr[34]; + let __v_137: G = __r_arr[35]; + let __v_138: G = __r_arr[36]; + let __v_139: G = __r_arr[37]; + let __v_140: G = __r_arr[38]; + let __v_141: G = __r_arr[39]; + let __v_142: G = __r_arr[40]; + let __v_143: G = __r_arr[41]; + let __v_144: G = __r_arr[42]; + let __v_145: G = __r_arr[43]; + let __v_146: G = __r_arr[44]; + let __v_147: G = __r_arr[45]; + let __v_148: G = __r_arr[46]; + let __v_149: G = __r_arr[47]; + let __v_150: G = __r_arr[48]; + let __v_151: G = __r_arr[49]; + let __v_152: G = __r_arr[50]; + let __v_153: G = __r_arr[51]; + let __v_154: G = __r_arr[52]; + let __v_155: G = __r_arr[53]; + let __v_156: G = __r_arr[54]; + let __v_157: G = __r_arr[55]; + let __v_158: G = __r_arr[56]; + let __v_159: G = __r_arr[57]; + let __v_160: G = __r_arr[58]; + let __v_161: G = __r_arr[59]; + let __v_162: G = __r_arr[60]; + let __v_163: G = __r_arr[61]; + let __v_164: G = __r_arr[62]; + let __v_165: G = __r_arr[63]; + let __v_166: G = __r_arr[64]; + let __v_167: G = __r_arr[65]; + let __v_168: G = __r_arr[66]; + match __v_102.as_canonical_u64() { + 0u64 => { + let __v_169: G = G::from_u64(1); + let __ret: [G; OUT_21] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_169: G = G::from_u64(4); + let __v_170: G = G::from_u64(8); + let __v_171: G = G::from_u64(103); + let __v_172: G = G::from_u64(230); + let __v_173: G = G::from_u64(9); + let __v_174: G = G::from_u64(106); + let __v_175: G = G::from_u64(133); + let __v_176: G = G::from_u64(174); + let __v_177: G = G::from_u64(103); + let __v_178: G = G::from_u64(187); + let __v_179: G = G::from_u64(114); + let __v_180: G = G::from_u64(243); + let __v_181: G = G::from_u64(110); + let __v_182: G = G::from_u64(60); + let __v_183: G = G::from_u64(58); + let __v_184: G = G::from_u64(245); + let __v_185: G = G::from_u64(79); + let __v_186: G = G::from_u64(165); + let __v_187: G = G::from_u64(127); + let __v_188: G = G::from_u64(82); + let __v_189: G = G::from_u64(14); + let __v_190: G = G::from_u64(81); + let __v_191: G = G::from_u64(140); + let __v_192: G = G::from_u64(104); + let __v_193: G = G::from_u64(5); + let __v_194: G = G::from_u64(155); + let __v_195: G = G::from_u64(171); + let __v_196: G = G::from_u64(217); + let __v_197: G = G::from_u64(131); + let __v_198: G = G::from_u64(31); + let __v_199: G = G::from_u64(25); + let __v_200: G = G::from_u64(205); + let __v_201: G = G::from_u64(224); + let __v_202: G = G::from_u64(91); + match __v_135.as_canonical_u64() { + 1u64 => { + let __v_203: G = (__v_170 * __v_66); + let __v_204: G = (__v_169 + __v_203); + let __v_205: G = G::from_u64(0); + let __v_206: G = G::from_u64(0); + let __v_207: G = G::from_u64(0); + let __v_208: G = G::from_u64(0); + let __v_209: G = G::from_u64(0); + let __v_210: G = G::from_u64(0); + let __v_211: G = G::from_u64(0); + let __v_212: G = G::from_u64(0); + let __v_213: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_214: G = __r_arr[0]; + let __v_215: G = __r_arr[1]; + let __v_216: G = __r_arr[2]; + let __v_217: G = __r_arr[3]; + let __v_218: G = __r_arr[4]; + let __v_219: G = __r_arr[5]; + let __v_220: G = __r_arr[6]; + let __v_221: G = __r_arr[7]; + let __v_222: G = __r_arr[8]; + let __v_223: G = __r_arr[9]; + let __v_224: G = __r_arr[10]; + let __v_225: G = __r_arr[11]; + let __v_226: G = __r_arr[12]; + let __v_227: G = __r_arr[13]; + let __v_228: G = __r_arr[14]; + let __v_229: G = __r_arr[15]; + let __v_230: G = __r_arr[16]; + let __v_231: G = __r_arr[17]; + let __v_232: G = __r_arr[18]; + let __v_233: G = __r_arr[19]; + let __v_234: G = __r_arr[20]; + let __v_235: G = __r_arr[21]; + let __v_236: G = __r_arr[22]; + let __v_237: G = __r_arr[23]; + let __v_238: G = __r_arr[24]; + let __v_239: G = __r_arr[25]; + let __v_240: G = __r_arr[26]; + let __v_241: G = __r_arr[27]; + let __v_242: G = __r_arr[28]; + let __v_243: G = __r_arr[29]; + let __v_244: G = __r_arr[30]; + let __v_245: G = __r_arr[31]; + let __v_246: G = G::from_u64(0); + let __v_247: G = G::from_u64(0); + let __v_248: G = G::from_u64(0); + let __v_249: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_21] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_248, __v_249, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_203: G = G::from_u64(0); + let __v_204: G = G::from_u64(0); + let __v_205: G = G::from_u64(0); + let __v_206: G = G::from_u64(0); + let __v_207: G = G::from_u64(0); + let __v_208: G = G::from_u64(0); + let __v_209: G = G::from_u64(0); + let __v_210: G = G::from_u64(0); + let __v_211: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_212: G = __r_arr[0]; + let __v_213: G = __r_arr[1]; + let __v_214: G = __r_arr[2]; + let __v_215: G = __r_arr[3]; + let __v_216: G = __r_arr[4]; + let __v_217: G = __r_arr[5]; + let __v_218: G = __r_arr[6]; + let __v_219: G = __r_arr[7]; + let __v_220: G = __r_arr[8]; + let __v_221: G = __r_arr[9]; + let __v_222: G = __r_arr[10]; + let __v_223: G = __r_arr[11]; + let __v_224: G = __r_arr[12]; + let __v_225: G = __r_arr[13]; + let __v_226: G = __r_arr[14]; + let __v_227: G = __r_arr[15]; + let __v_228: G = __r_arr[16]; + let __v_229: G = __r_arr[17]; + let __v_230: G = __r_arr[18]; + let __v_231: G = __r_arr[19]; + let __v_232: G = __r_arr[20]; + let __v_233: G = __r_arr[21]; + let __v_234: G = __r_arr[22]; + let __v_235: G = __r_arr[23]; + let __v_236: G = __r_arr[24]; + let __v_237: G = __r_arr[25]; + let __v_238: G = __r_arr[26]; + let __v_239: G = __r_arr[27]; + let __v_240: G = __r_arr[28]; + let __v_241: G = __r_arr[29]; + let __v_242: G = __r_arr[30]; + let __v_243: G = __r_arr[31]; + let __v_244: G = G::from_u64(0); + let __v_245: G = G::from_u64(0); + let __v_246: G = G::from_u64(0); + let __v_247: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_21] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_22: usize = 34; +const IN_22: usize = 34; +const OUT_22: usize = 32; +fn aiur_fn_22( + inp: [G; IN_22], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_22], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = __loaded[32]; + let __v_67: G = __loaded[33]; + match __v_34.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_68: G = __loaded[0]; + let __v_69: G = __loaded[1]; + let __v_70: G = __loaded[2]; + let __v_71: G = __loaded[3]; + let __v_72: G = __loaded[4]; + let __v_73: G = __loaded[5]; + let __v_74: G = __loaded[6]; + let __v_75: G = __loaded[7]; + let __v_76: G = __loaded[8]; + let __v_77: G = __loaded[9]; + let __v_78: G = __loaded[10]; + let __v_79: G = __loaded[11]; + let __v_80: G = __loaded[12]; + let __v_81: G = __loaded[13]; + let __v_82: G = __loaded[14]; + let __v_83: G = __loaded[15]; + let __v_84: G = __loaded[16]; + let __v_85: G = __loaded[17]; + let __v_86: G = __loaded[18]; + let __v_87: G = __loaded[19]; + let __v_88: G = __loaded[20]; + let __v_89: G = __loaded[21]; + let __v_90: G = __loaded[22]; + let __v_91: G = __loaded[23]; + let __v_92: G = __loaded[24]; + let __v_93: G = __loaded[25]; + let __v_94: G = __loaded[26]; + let __v_95: G = __loaded[27]; + let __v_96: G = __loaded[28]; + let __v_97: G = __loaded[29]; + let __v_98: G = __loaded[30]; + let __v_99: G = __loaded[31]; + let __v_100: G = __loaded[32]; + let __v_101: G = __loaded[33]; + let __v_102: G = G::from_u64(1); + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_102]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = result.output.try_into().unwrap(); __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_103: G = __r_arr[0]; + let __v_104: G = __r_arr[1]; + let __v_105: G = __r_arr[2]; + let __v_106: G = __r_arr[3]; + let __v_107: G = __r_arr[4]; + let __v_108: G = __r_arr[5]; + let __v_109: G = __r_arr[6]; + let __v_110: G = __r_arr[7]; + let __v_111: G = __r_arr[8]; + let __v_112: G = __r_arr[9]; + let __v_113: G = __r_arr[10]; + let __v_114: G = __r_arr[11]; + let __v_115: G = __r_arr[12]; + let __v_116: G = __r_arr[13]; + let __v_117: G = __r_arr[14]; + let __v_118: G = __r_arr[15]; + let __v_119: G = __r_arr[16]; + let __v_120: G = __r_arr[17]; + let __v_121: G = __r_arr[18]; + let __v_122: G = __r_arr[19]; + let __v_123: G = __r_arr[20]; + let __v_124: G = __r_arr[21]; + let __v_125: G = __r_arr[22]; + let __v_126: G = __r_arr[23]; + let __v_127: G = __r_arr[24]; + let __v_128: G = __r_arr[25]; + let __v_129: G = __r_arr[26]; + let __v_130: G = __r_arr[27]; + let __v_131: G = __r_arr[28]; + let __v_132: G = __r_arr[29]; + let __v_133: G = __r_arr[30]; + let __v_134: G = __r_arr[31]; + let __v_135: G = __r_arr[32]; + let __v_136: G = __r_arr[33]; + let __v_137: G = __r_arr[34]; + let __v_138: G = __r_arr[35]; + let __v_139: G = __r_arr[36]; + let __v_140: G = __r_arr[37]; + let __v_141: G = __r_arr[38]; + let __v_142: G = __r_arr[39]; + let __v_143: G = __r_arr[40]; + let __v_144: G = __r_arr[41]; + let __v_145: G = __r_arr[42]; + let __v_146: G = __r_arr[43]; + let __v_147: G = __r_arr[44]; + let __v_148: G = __r_arr[45]; + let __v_149: G = __r_arr[46]; + let __v_150: G = __r_arr[47]; + let __v_151: G = __r_arr[48]; + let __v_152: G = __r_arr[49]; + let __v_153: G = __r_arr[50]; + let __v_154: G = __r_arr[51]; + let __v_155: G = __r_arr[52]; + let __v_156: G = __r_arr[53]; + let __v_157: G = __r_arr[54]; + let __v_158: G = __r_arr[55]; + let __v_159: G = __r_arr[56]; + let __v_160: G = __r_arr[57]; + let __v_161: G = __r_arr[58]; + let __v_162: G = __r_arr[59]; + let __v_163: G = __r_arr[60]; + let __v_164: G = __r_arr[61]; + let __v_165: G = __r_arr[62]; + let __v_166: G = __r_arr[63]; + let __v_167: G = __r_arr[64]; + let __v_168: G = __r_arr[65]; + let __v_169: G = __r_arr[66]; + match __v_103.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __v_170: G = __r_arr[0]; + let __v_171: G = __r_arr[1]; + let __v_172: G = __r_arr[2]; + let __v_173: G = __r_arr[3]; + let __v_174: G = __r_arr[4]; + let __v_175: G = __r_arr[5]; + let __v_176: G = __r_arr[6]; + let __v_177: G = __r_arr[7]; + let __v_178: G = __r_arr[8]; + let __v_179: G = __r_arr[9]; + let __v_180: G = __r_arr[10]; + let __v_181: G = __r_arr[11]; + let __v_182: G = __r_arr[12]; + let __v_183: G = __r_arr[13]; + let __v_184: G = __r_arr[14]; + let __v_185: G = __r_arr[15]; + let __v_186: G = __r_arr[16]; + let __v_187: G = __r_arr[17]; + let __v_188: G = __r_arr[18]; + let __v_189: G = __r_arr[19]; + let __v_190: G = __r_arr[20]; + let __v_191: G = __r_arr[21]; + let __v_192: G = __r_arr[22]; + let __v_193: G = __r_arr[23]; + let __v_194: G = __r_arr[24]; + let __v_195: G = __r_arr[25]; + let __v_196: G = __r_arr[26]; + let __v_197: G = __r_arr[27]; + let __v_198: G = __r_arr[28]; + let __v_199: G = __r_arr[29]; + let __v_200: G = __r_arr[30]; + let __v_201: G = __r_arr[31]; + let __ret: [G; OUT_22] = [__v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_170: G = G::from_u64(0); + let __v_171: G = { let __values: [G; 34] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_170, __v_171, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __v_172: G = __r_arr[0]; + let __v_173: G = __r_arr[1]; + let __v_174: G = __r_arr[2]; + let __v_175: G = __r_arr[3]; + let __v_176: G = __r_arr[4]; + let __v_177: G = __r_arr[5]; + let __v_178: G = __r_arr[6]; + let __v_179: G = __r_arr[7]; + let __v_180: G = __r_arr[8]; + let __v_181: G = __r_arr[9]; + let __v_182: G = __r_arr[10]; + let __v_183: G = __r_arr[11]; + let __v_184: G = __r_arr[12]; + let __v_185: G = __r_arr[13]; + let __v_186: G = __r_arr[14]; + let __v_187: G = __r_arr[15]; + let __v_188: G = __r_arr[16]; + let __v_189: G = __r_arr[17]; + let __v_190: G = __r_arr[18]; + let __v_191: G = __r_arr[19]; + let __v_192: G = __r_arr[20]; + let __v_193: G = __r_arr[21]; + let __v_194: G = __r_arr[22]; + let __v_195: G = __r_arr[23]; + let __v_196: G = __r_arr[24]; + let __v_197: G = __r_arr[25]; + let __v_198: G = __r_arr[26]; + let __v_199: G = __r_arr[27]; + let __v_200: G = __r_arr[28]; + let __v_201: G = __r_arr[29]; + let __v_202: G = __r_arr[30]; + let __v_203: G = __r_arr[31]; + let __ret: [G; OUT_22] = [__v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_23: usize = 7; +const IN_23: usize = 7; +const OUT_23: usize = 1; +fn aiur_fn_23( + inp: [G; IN_23], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_23], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = result.output.try_into().unwrap(); __ret } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_10]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + match __v_2.as_canonical_u64() { + 63u64 => { + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = result.output.try_into().unwrap(); __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_12]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_2 + __v_12); + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_3 + __v_14); + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_16]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 64; +fn aiur_fn_24( + inp: [G; IN_24], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_24], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_22: G = __loaded[0]; + let __v_23: G = __loaded[1]; + let __v_24: G = __loaded[2]; + match __v_22.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + match __v_28.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + match __v_34.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + match __v_37.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_40: G = __loaded[0]; + let __v_41: G = __loaded[1]; + let __v_42: G = __loaded[2]; + match __v_40.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_43: G = __loaded[0]; + let __v_44: G = __loaded[1]; + let __v_45: G = __loaded[2]; + match __v_43.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_46: G = __loaded[0]; + let __v_47: G = __loaded[1]; + let __v_48: G = __loaded[2]; + match __v_46.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_49: G = __loaded[0]; + let __v_50: G = __loaded[1]; + let __v_51: G = __loaded[2]; + match __v_49.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + match __v_52.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_55: G = __loaded[0]; + let __v_56: G = __loaded[1]; + let __v_57: G = __loaded[2]; + match __v_55.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_58: G = __loaded[0]; + let __v_59: G = __loaded[1]; + let __v_60: G = __loaded[2]; + match __v_58.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_61: G = __loaded[0]; + let __v_62: G = __loaded[1]; + let __v_63: G = __loaded[2]; + match __v_61.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_64: G = __loaded[0]; + let __v_65: G = __loaded[1]; + let __v_66: G = __loaded[2]; + match __v_64.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_67: G = __loaded[0]; + let __v_68: G = __loaded[1]; + let __v_69: G = __loaded[2]; + match __v_67.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_70: G = __loaded[0]; + let __v_71: G = __loaded[1]; + let __v_72: G = __loaded[2]; + match __v_70.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_73: G = __loaded[0]; + let __v_74: G = __loaded[1]; + let __v_75: G = __loaded[2]; + match __v_73.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_76: G = __loaded[0]; + let __v_77: G = __loaded[1]; + let __v_78: G = __loaded[2]; + match __v_76.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_79: G = __loaded[0]; + let __v_80: G = __loaded[1]; + let __v_81: G = __loaded[2]; + match __v_79.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_82: G = __loaded[0]; + let __v_83: G = __loaded[1]; + let __v_84: G = __loaded[2]; + match __v_82.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_85: G = __loaded[0]; + let __v_86: G = __loaded[1]; + let __v_87: G = __loaded[2]; + match __v_85.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_88: G = __loaded[0]; + let __v_89: G = __loaded[1]; + let __v_90: G = __loaded[2]; + match __v_88.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_91: G = __loaded[0]; + let __v_92: G = __loaded[1]; + let __v_93: G = __loaded[2]; + match __v_91.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_94: G = __loaded[0]; + let __v_95: G = __loaded[1]; + let __v_96: G = __loaded[2]; + match __v_94.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_97: G = __loaded[0]; + let __v_98: G = __loaded[1]; + let __v_99: G = __loaded[2]; + match __v_97.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_100: G = __loaded[0]; + let __v_101: G = __loaded[1]; + let __v_102: G = __loaded[2]; + match __v_100.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_103: G = __loaded[0]; + let __v_104: G = __loaded[1]; + let __v_105: G = __loaded[2]; + match __v_103.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_106: G = __loaded[0]; + let __v_107: G = __loaded[1]; + let __v_108: G = __loaded[2]; + match __v_106.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_109: G = __loaded[0]; + let __v_110: G = __loaded[1]; + let __v_111: G = __loaded[2]; + match __v_109.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_112: G = __loaded[0]; + let __v_113: G = __loaded[1]; + let __v_114: G = __loaded[2]; + match __v_112.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_115: G = __loaded[0]; + let __v_116: G = __loaded[1]; + let __v_117: G = __loaded[2]; + match __v_115.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_118: G = __loaded[0]; + let __v_119: G = __loaded[1]; + let __v_120: G = __loaded[2]; + match __v_118.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_121: G = __loaded[0]; + let __v_122: G = __loaded[1]; + let __v_123: G = __loaded[2]; + match __v_121.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_124: G = __loaded[0]; + let __v_125: G = __loaded[1]; + let __v_126: G = __loaded[2]; + match __v_124.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_127: G = __loaded[0]; + let __v_128: G = __loaded[1]; + let __v_129: G = __loaded[2]; + match __v_127.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_130: G = __loaded[0]; + let __v_131: G = __loaded[1]; + let __v_132: G = __loaded[2]; + match __v_130.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_133: G = __loaded[0]; + let __v_134: G = __loaded[1]; + let __v_135: G = __loaded[2]; + match __v_133.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_136: G = __loaded[0]; + let __v_137: G = __loaded[1]; + let __v_138: G = __loaded[2]; + match __v_136.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_139: G = __loaded[0]; + let __v_140: G = __loaded[1]; + let __v_141: G = __loaded[2]; + match __v_139.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_142: G = __loaded[0]; + let __v_143: G = __loaded[1]; + let __v_144: G = __loaded[2]; + match __v_142.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_145: G = __loaded[0]; + let __v_146: G = __loaded[1]; + let __v_147: G = __loaded[2]; + match __v_145.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_148: G = __loaded[0]; + let __v_149: G = __loaded[1]; + let __v_150: G = __loaded[2]; + match __v_148.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_151: G = __loaded[0]; + let __v_152: G = __loaded[1]; + let __v_153: G = __loaded[2]; + match __v_151.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_154: G = __loaded[0]; + let __v_155: G = __loaded[1]; + let __v_156: G = __loaded[2]; + match __v_154.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_157: G = __loaded[0]; + let __v_158: G = __loaded[1]; + let __v_159: G = __loaded[2]; + match __v_157.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_160: G = __loaded[0]; + let __v_161: G = __loaded[1]; + let __v_162: G = __loaded[2]; + match __v_160.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_163: G = __loaded[0]; + let __v_164: G = __loaded[1]; + let __v_165: G = __loaded[2]; + match __v_163.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_166: G = __loaded[0]; + let __v_167: G = __loaded[1]; + let __v_168: G = __loaded[2]; + match __v_166.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_169: G = __loaded[0]; + let __v_170: G = __loaded[1]; + let __v_171: G = __loaded[2]; + match __v_169.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_172: G = __loaded[0]; + let __v_173: G = __loaded[1]; + let __v_174: G = __loaded[2]; + match __v_172.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_175: G = __loaded[0]; + let __v_176: G = __loaded[1]; + let __v_177: G = __loaded[2]; + match __v_175.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_178: G = __loaded[0]; + let __v_179: G = __loaded[1]; + let __v_180: G = __loaded[2]; + match __v_178.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_181: G = __loaded[0]; + let __v_182: G = __loaded[1]; + let __v_183: G = __loaded[2]; + match __v_181.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_184: G = __loaded[0]; + let __v_185: G = __loaded[1]; + let __v_186: G = __loaded[2]; + match __v_184.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_187: G = __loaded[0]; + let __v_188: G = __loaded[1]; + let __v_189: G = __loaded[2]; + match __v_187.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_190: G = __loaded[0]; + let __v_191: G = __loaded[1]; + let __v_192: G = __loaded[2]; + match __v_190.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_24] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; + record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_25: usize = 2; +const IN_25: usize = 2; +const OUT_25: usize = 1; +fn aiur_fn_25( + inp: [G; IN_25], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_25], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_25] = [__v_0]; + record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = result.output.try_into().unwrap(); __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_25] = [__v_7]; + record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_26: usize = 6; +const IN_26: usize = 6; +const OUT_26: usize = 1; +fn aiur_fn_26( + inp: [G; IN_26], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_26], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(8); + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + match __v_9.as_canonical_u64() { + 0u64 => { + match __v_10.as_canonical_u64() { + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + match __v_12.as_canonical_u64() { + 0u64 => { + match __v_13.as_canonical_u64() { + 0u64 => { + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_17: G = (__v_6 + __v_7); + let __v_18: G = (__v_8 + __v_17); + let __v_19: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + let __v_31: G = __loaded[11]; + let __v_32: G = __loaded[12]; + let __v_33: G = __loaded[13]; + let __v_34: G = __loaded[14]; + let __v_35: G = __loaded[15]; + let __v_36: G = __loaded[16]; + let __v_37: G = __loaded[17]; + let __v_38: G = __loaded[18]; + let __v_39: G = __loaded[19]; + let __v_40: G = __loaded[20]; + let __v_41: G = __loaded[21]; + let __v_42: G = __loaded[22]; + let __v_43: G = __loaded[23]; + let __v_44: G = __loaded[24]; + let __v_45: G = __loaded[25]; + let __v_46: G = __loaded[26]; + let __v_47: G = __loaded[27]; + let __v_48: G = __loaded[28]; + let __v_49: G = __loaded[29]; + let __v_50: G = __loaded[30]; + let __v_51: G = __loaded[31]; + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __v_78: G = G::from_u64(0); + let __v_79: G = G::from_u64(0); + let __v_80: G = G::from_u64(0); + let __v_81: G = G::from_u64(0); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = G::from_u64(0); + let __v_85: G = G::from_u64(0); + let __v_86: G = G::from_u64(0); + let __v_87: G = G::from_u64(0); + let __v_88: G = G::from_u64(0); + let __v_89: G = G::from_u64(0); + let __v_90: G = G::from_u64(0); + let __v_91: G = G::from_u64(0); + let __v_92: G = G::from_u64(0); + let __v_93: G = G::from_u64(0); + let __v_94: G = G::from_u64(0); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = G::from_u64(0); + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(0); + let __v_100: G = G::from_u64(0); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = G::from_u64(0); + let __v_104: G = G::from_u64(0); + let __v_105: G = G::from_u64(0); + let __v_106: G = G::from_u64(0); + let __v_107: G = G::from_u64(0); + let __v_108: G = G::from_u64(0); + let __v_109: G = G::from_u64(0); + let __v_110: G = G::from_u64(0); + let __v_111: G = G::from_u64(0); + let __v_112: G = G::from_u64(0); + let __v_113: G = G::from_u64(0); + let __v_114: G = G::from_u64(0); + let __v_115: G = G::from_u64(0); + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_116: G = __loaded[0]; + let __v_117: G = __loaded[1]; + let __v_118: G = __loaded[2]; + let __v_119: G = __loaded[3]; + let __v_120: G = __loaded[4]; + let __v_121: G = __loaded[5]; + let __v_122: G = __loaded[6]; + let __v_123: G = __loaded[7]; + let __v_124: G = G::from_u64(0); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_125: G = __r_arr[0]; + let __v_126: G = __r_arr[1]; + let __v_127: G = __r_arr[2]; + let __v_128: G = __r_arr[3]; + let __v_129: G = __r_arr[4]; + let __v_130: G = __r_arr[5]; + let __v_131: G = __r_arr[6]; + let __v_132: G = __r_arr[7]; + let __v_133: G = __r_arr[8]; + let __v_134: G = __r_arr[9]; + let __v_135: G = __r_arr[10]; + let __v_136: G = __r_arr[11]; + let __v_137: G = __r_arr[12]; + let __v_138: G = __r_arr[13]; + let __v_139: G = __r_arr[14]; + let __v_140: G = __r_arr[15]; + let __v_141: G = __r_arr[16]; + let __v_142: G = __r_arr[17]; + let __v_143: G = __r_arr[18]; + let __v_144: G = __r_arr[19]; + let __v_145: G = __r_arr[20]; + let __v_146: G = __r_arr[21]; + let __v_147: G = __r_arr[22]; + let __v_148: G = __r_arr[23]; + let __v_149: G = __r_arr[24]; + let __v_150: G = __r_arr[25]; + let __v_151: G = __r_arr[26]; + let __v_152: G = __r_arr[27]; + let __v_153: G = __r_arr[28]; + let __v_154: G = __r_arr[29]; + let __v_155: G = __r_arr[30]; + let __v_156: G = __r_arr[31]; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_157]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __v_28: G = __loaded[18]; + let __v_29: G = __loaded[19]; + let __v_30: G = __loaded[20]; + let __v_31: G = __loaded[21]; + let __v_32: G = __loaded[22]; + let __v_33: G = __loaded[23]; + let __v_34: G = __loaded[24]; + let __v_35: G = __loaded[25]; + let __v_36: G = __loaded[26]; + let __v_37: G = __loaded[27]; + let __v_38: G = __loaded[28]; + let __v_39: G = __loaded[29]; + let __v_40: G = __loaded[30]; + let __v_41: G = __loaded[31]; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_42]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_17 * __v_8); + let __v_19: G = (__v_2 - __v_1); + let __v_20: G = G::from_bool((__v_19 == G::ZERO)); + let __v_21: G = (__v_20 * __v_6); + let __v_22: G = (__v_18 + __v_21); + let __v_23: G = (__v_7 + __v_22); + let __v_24: G = G::from_u64(64); + let __v_25: G = (__v_24 - __v_1); + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = result.output.try_into().unwrap(); __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = result.output.try_into().unwrap(); __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = __r_arr[3]; + let __v_31: G = __r_arr[4]; + let __v_32: G = __r_arr[5]; + let __v_33: G = __r_arr[6]; + let __v_34: G = __r_arr[7]; + let __v_35: G = __r_arr[8]; + let __v_36: G = __r_arr[9]; + let __v_37: G = __r_arr[10]; + let __v_38: G = __r_arr[11]; + let __v_39: G = __r_arr[12]; + let __v_40: G = __r_arr[13]; + let __v_41: G = __r_arr[14]; + let __v_42: G = __r_arr[15]; + let __v_43: G = __r_arr[16]; + let __v_44: G = __r_arr[17]; + let __v_45: G = __r_arr[18]; + let __v_46: G = __r_arr[19]; + let __v_47: G = __r_arr[20]; + let __v_48: G = __r_arr[21]; + let __v_49: G = __r_arr[22]; + let __v_50: G = __r_arr[23]; + let __v_51: G = __r_arr[24]; + let __v_52: G = __r_arr[25]; + let __v_53: G = __r_arr[26]; + let __v_54: G = __r_arr[27]; + let __v_55: G = __r_arr[28]; + let __v_56: G = __r_arr[29]; + let __v_57: G = __r_arr[30]; + let __v_58: G = __r_arr[31]; + let __v_59: G = __r_arr[32]; + let __v_60: G = __r_arr[33]; + let __v_61: G = __r_arr[34]; + let __v_62: G = __r_arr[35]; + let __v_63: G = __r_arr[36]; + let __v_64: G = __r_arr[37]; + let __v_65: G = __r_arr[38]; + let __v_66: G = __r_arr[39]; + let __v_67: G = __r_arr[40]; + let __v_68: G = __r_arr[41]; + let __v_69: G = __r_arr[42]; + let __v_70: G = __r_arr[43]; + let __v_71: G = __r_arr[44]; + let __v_72: G = __r_arr[45]; + let __v_73: G = __r_arr[46]; + let __v_74: G = __r_arr[47]; + let __v_75: G = __r_arr[48]; + let __v_76: G = __r_arr[49]; + let __v_77: G = __r_arr[50]; + let __v_78: G = __r_arr[51]; + let __v_79: G = __r_arr[52]; + let __v_80: G = __r_arr[53]; + let __v_81: G = __r_arr[54]; + let __v_82: G = __r_arr[55]; + let __v_83: G = __r_arr[56]; + let __v_84: G = __r_arr[57]; + let __v_85: G = __r_arr[58]; + let __v_86: G = __r_arr[59]; + let __v_87: G = __r_arr[60]; + let __v_88: G = __r_arr[61]; + let __v_89: G = __r_arr[62]; + let __v_90: G = __r_arr[63]; + let __v_91: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_92: G = __loaded[0]; + let __v_93: G = __loaded[1]; + let __v_94: G = __loaded[2]; + let __v_95: G = __loaded[3]; + let __v_96: G = __loaded[4]; + let __v_97: G = __loaded[5]; + let __v_98: G = __loaded[6]; + let __v_99: G = __loaded[7]; + let __v_100: G = __loaded[8]; + let __v_101: G = __loaded[9]; + let __v_102: G = __loaded[10]; + let __v_103: G = __loaded[11]; + let __v_104: G = __loaded[12]; + let __v_105: G = __loaded[13]; + let __v_106: G = __loaded[14]; + let __v_107: G = __loaded[15]; + let __v_108: G = __loaded[16]; + let __v_109: G = __loaded[17]; + let __v_110: G = __loaded[18]; + let __v_111: G = __loaded[19]; + let __v_112: G = __loaded[20]; + let __v_113: G = __loaded[21]; + let __v_114: G = __loaded[22]; + let __v_115: G = __loaded[23]; + let __v_116: G = __loaded[24]; + let __v_117: G = __loaded[25]; + let __v_118: G = __loaded[26]; + let __v_119: G = __loaded[27]; + let __v_120: G = __loaded[28]; + let __v_121: G = __loaded[29]; + let __v_122: G = __loaded[30]; + let __v_123: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_124: G = __loaded[0]; + let __v_125: G = __loaded[1]; + let __v_126: G = __loaded[2]; + let __v_127: G = __loaded[3]; + let __v_128: G = __loaded[4]; + let __v_129: G = __loaded[5]; + let __v_130: G = __loaded[6]; + let __v_131: G = __loaded[7]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_132: G = __r_arr[0]; + let __v_133: G = __r_arr[1]; + let __v_134: G = __r_arr[2]; + let __v_135: G = __r_arr[3]; + let __v_136: G = __r_arr[4]; + let __v_137: G = __r_arr[5]; + let __v_138: G = __r_arr[6]; + let __v_139: G = __r_arr[7]; + let __v_140: G = __r_arr[8]; + let __v_141: G = __r_arr[9]; + let __v_142: G = __r_arr[10]; + let __v_143: G = __r_arr[11]; + let __v_144: G = __r_arr[12]; + let __v_145: G = __r_arr[13]; + let __v_146: G = __r_arr[14]; + let __v_147: G = __r_arr[15]; + let __v_148: G = __r_arr[16]; + let __v_149: G = __r_arr[17]; + let __v_150: G = __r_arr[18]; + let __v_151: G = __r_arr[19]; + let __v_152: G = __r_arr[20]; + let __v_153: G = __r_arr[21]; + let __v_154: G = __r_arr[22]; + let __v_155: G = __r_arr[23]; + let __v_156: G = __r_arr[24]; + let __v_157: G = __r_arr[25]; + let __v_158: G = __r_arr[26]; + let __v_159: G = __r_arr[27]; + let __v_160: G = __r_arr[28]; + let __v_161: G = __r_arr[29]; + let __v_162: G = __r_arr[30]; + let __v_163: G = __r_arr[31]; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_164]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_27: usize = 6; +const IN_27: usize = 6; +const OUT_27: usize = 1; +fn aiur_fn_27( + inp: [G; IN_27], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_27], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(8); + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = result.output.try_into().unwrap(); __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = __r_arr[3]; + let __v_13: G = __r_arr[4]; + let __v_14: G = __r_arr[5]; + let __v_15: G = __r_arr[6]; + let __v_16: G = __r_arr[7]; + let __v_17: G = __r_arr[8]; + let __v_18: G = __r_arr[9]; + let __v_19: G = __r_arr[10]; + let __v_20: G = __r_arr[11]; + let __v_21: G = __r_arr[12]; + let __v_22: G = __r_arr[13]; + let __v_23: G = __r_arr[14]; + let __v_24: G = __r_arr[15]; + let __v_25: G = __r_arr[16]; + let __v_26: G = __r_arr[17]; + let __v_27: G = __r_arr[18]; + let __v_28: G = __r_arr[19]; + let __v_29: G = __r_arr[20]; + let __v_30: G = __r_arr[21]; + let __v_31: G = __r_arr[22]; + let __v_32: G = __r_arr[23]; + let __v_33: G = __r_arr[24]; + let __v_34: G = __r_arr[25]; + let __v_35: G = __r_arr[26]; + let __v_36: G = __r_arr[27]; + let __v_37: G = __r_arr[28]; + let __v_38: G = __r_arr[29]; + let __v_39: G = __r_arr[30]; + let __v_40: G = __r_arr[31]; + let __v_41: G = __r_arr[32]; + let __v_42: G = __r_arr[33]; + let __v_43: G = __r_arr[34]; + let __v_44: G = __r_arr[35]; + let __v_45: G = __r_arr[36]; + let __v_46: G = __r_arr[37]; + let __v_47: G = __r_arr[38]; + let __v_48: G = __r_arr[39]; + let __v_49: G = __r_arr[40]; + let __v_50: G = __r_arr[41]; + let __v_51: G = __r_arr[42]; + let __v_52: G = __r_arr[43]; + let __v_53: G = __r_arr[44]; + let __v_54: G = __r_arr[45]; + let __v_55: G = __r_arr[46]; + let __v_56: G = __r_arr[47]; + let __v_57: G = __r_arr[48]; + let __v_58: G = __r_arr[49]; + let __v_59: G = __r_arr[50]; + let __v_60: G = __r_arr[51]; + let __v_61: G = __r_arr[52]; + let __v_62: G = __r_arr[53]; + let __v_63: G = __r_arr[54]; + let __v_64: G = __r_arr[55]; + let __v_65: G = __r_arr[56]; + let __v_66: G = __r_arr[57]; + let __v_67: G = __r_arr[58]; + let __v_68: G = __r_arr[59]; + let __v_69: G = __r_arr[60]; + let __v_70: G = __r_arr[61]; + let __v_71: G = __r_arr[62]; + let __v_72: G = __r_arr[63]; + match __v_2.as_canonical_u64() { + 1023u64 => { + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_74: G = __loaded[0]; + let __v_75: G = __loaded[1]; + let __v_76: G = __loaded[2]; + let __v_77: G = __loaded[3]; + let __v_78: G = __loaded[4]; + let __v_79: G = __loaded[5]; + let __v_80: G = __loaded[6]; + let __v_81: G = __loaded[7]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __v_83: G = (__v_73 * __v_82); + let __v_84: G = (__v_8 * __v_83); + let __v_85: G = (__v_84 + __v_7); + let __v_86: G = G::from_u64(103); + let __v_87: G = G::from_u64(230); + let __v_88: G = G::from_u64(9); + let __v_89: G = G::from_u64(106); + let __v_90: G = G::from_u64(133); + let __v_91: G = G::from_u64(174); + let __v_92: G = G::from_u64(103); + let __v_93: G = G::from_u64(187); + let __v_94: G = G::from_u64(114); + let __v_95: G = G::from_u64(243); + let __v_96: G = G::from_u64(110); + let __v_97: G = G::from_u64(60); + let __v_98: G = G::from_u64(58); + let __v_99: G = G::from_u64(245); + let __v_100: G = G::from_u64(79); + let __v_101: G = G::from_u64(165); + let __v_102: G = G::from_u64(127); + let __v_103: G = G::from_u64(82); + let __v_104: G = G::from_u64(14); + let __v_105: G = G::from_u64(81); + let __v_106: G = G::from_u64(140); + let __v_107: G = G::from_u64(104); + let __v_108: G = G::from_u64(5); + let __v_109: G = G::from_u64(155); + let __v_110: G = G::from_u64(171); + let __v_111: G = G::from_u64(217); + let __v_112: G = G::from_u64(131); + let __v_113: G = G::from_u64(31); + let __v_114: G = G::from_u64(25); + let __v_115: G = G::from_u64(205); + let __v_116: G = G::from_u64(224); + let __v_117: G = G::from_u64(91); + let __v_118: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_119: G = __loaded[0]; + let __v_120: G = __loaded[1]; + let __v_121: G = __loaded[2]; + let __v_122: G = __loaded[3]; + let __v_123: G = __loaded[4]; + let __v_124: G = __loaded[5]; + let __v_125: G = __loaded[6]; + let __v_126: G = __loaded[7]; + let __v_127: G = __loaded[8]; + let __v_128: G = __loaded[9]; + let __v_129: G = __loaded[10]; + let __v_130: G = __loaded[11]; + let __v_131: G = __loaded[12]; + let __v_132: G = __loaded[13]; + let __v_133: G = __loaded[14]; + let __v_134: G = __loaded[15]; + let __v_135: G = __loaded[16]; + let __v_136: G = __loaded[17]; + let __v_137: G = __loaded[18]; + let __v_138: G = __loaded[19]; + let __v_139: G = __loaded[20]; + let __v_140: G = __loaded[21]; + let __v_141: G = __loaded[22]; + let __v_142: G = __loaded[23]; + let __v_143: G = __loaded[24]; + let __v_144: G = __loaded[25]; + let __v_145: G = __loaded[26]; + let __v_146: G = __loaded[27]; + let __v_147: G = __loaded[28]; + let __v_148: G = __loaded[29]; + let __v_149: G = __loaded[30]; + let __v_150: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_151: G = __loaded[0]; + let __v_152: G = __loaded[1]; + let __v_153: G = __loaded[2]; + let __v_154: G = __loaded[3]; + let __v_155: G = __loaded[4]; + let __v_156: G = __loaded[5]; + let __v_157: G = __loaded[6]; + let __v_158: G = __loaded[7]; + let __v_159: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_160: G = __r_arr[0]; + let __v_161: G = __r_arr[1]; + let __v_162: G = __r_arr[2]; + let __v_163: G = __r_arr[3]; + let __v_164: G = __r_arr[4]; + let __v_165: G = __r_arr[5]; + let __v_166: G = __r_arr[6]; + let __v_167: G = __r_arr[7]; + let __v_168: G = __r_arr[8]; + let __v_169: G = __r_arr[9]; + let __v_170: G = __r_arr[10]; + let __v_171: G = __r_arr[11]; + let __v_172: G = __r_arr[12]; + let __v_173: G = __r_arr[13]; + let __v_174: G = __r_arr[14]; + let __v_175: G = __r_arr[15]; + let __v_176: G = __r_arr[16]; + let __v_177: G = __r_arr[17]; + let __v_178: G = __r_arr[18]; + let __v_179: G = __r_arr[19]; + let __v_180: G = __r_arr[20]; + let __v_181: G = __r_arr[21]; + let __v_182: G = __r_arr[22]; + let __v_183: G = __r_arr[23]; + let __v_184: G = __r_arr[24]; + let __v_185: G = __r_arr[25]; + let __v_186: G = __r_arr[26]; + let __v_187: G = __r_arr[27]; + let __v_188: G = __r_arr[28]; + let __v_189: G = __r_arr[29]; + let __v_190: G = __r_arr[30]; + let __v_191: G = __r_arr[31]; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_193: G = G::from_u64(1); + let __v_194: G = G::from_u64(1); + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_196: G = G::from_u64(0); + let __v_197: G = G::from_u64(0); + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_198: G = __loaded[0]; + let __v_199: G = __loaded[1]; + let __v_200: G = __loaded[2]; + let __v_201: G = __loaded[3]; + let __v_202: G = __loaded[4]; + let __v_203: G = __loaded[5]; + let __v_204: G = __loaded[6]; + let __v_205: G = __loaded[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_206: G = __r_arr[0]; + let __v_207: G = __r_arr[1]; + let __v_208: G = __r_arr[2]; + let __v_209: G = __r_arr[3]; + let __v_210: G = __r_arr[4]; + let __v_211: G = __r_arr[5]; + let __v_212: G = __r_arr[6]; + let __v_213: G = __r_arr[7]; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_216: G = __r_arr[0]; + let __ret: [G; OUT_27] = [__v_216]; + record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = (__v_73 * __v_7); + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_76: G = __loaded[0]; + let __v_77: G = __loaded[1]; + let __v_78: G = __loaded[2]; + let __v_79: G = __loaded[3]; + let __v_80: G = __loaded[4]; + let __v_81: G = __loaded[5]; + let __v_82: G = __loaded[6]; + let __v_83: G = __loaded[7]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = (__v_84 * __v_8); + let __v_86: G = (__v_75 * __v_85); + let __v_87: G = G::from_u64(63); + let __v_88: G = (__v_2 - __v_87); + let __v_89: G = G::from_bool((__v_88 == G::ZERO)); + let __v_90: G = (__v_89 * __v_6); + let __v_91: G = (__v_86 + __v_90); + let __v_92: G = (__v_74 + __v_91); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_93: G = __loaded[0]; + let __v_94: G = __loaded[1]; + let __v_95: G = __loaded[2]; + let __v_96: G = __loaded[3]; + let __v_97: G = __loaded[4]; + let __v_98: G = __loaded[5]; + let __v_99: G = __loaded[6]; + let __v_100: G = __loaded[7]; + let __v_101: G = __loaded[8]; + let __v_102: G = __loaded[9]; + let __v_103: G = __loaded[10]; + let __v_104: G = __loaded[11]; + let __v_105: G = __loaded[12]; + let __v_106: G = __loaded[13]; + let __v_107: G = __loaded[14]; + let __v_108: G = __loaded[15]; + let __v_109: G = __loaded[16]; + let __v_110: G = __loaded[17]; + let __v_111: G = __loaded[18]; + let __v_112: G = __loaded[19]; + let __v_113: G = __loaded[20]; + let __v_114: G = __loaded[21]; + let __v_115: G = __loaded[22]; + let __v_116: G = __loaded[23]; + let __v_117: G = __loaded[24]; + let __v_118: G = __loaded[25]; + let __v_119: G = __loaded[26]; + let __v_120: G = __loaded[27]; + let __v_121: G = __loaded[28]; + let __v_122: G = __loaded[29]; + let __v_123: G = __loaded[30]; + let __v_124: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_125: G = __loaded[0]; + let __v_126: G = __loaded[1]; + let __v_127: G = __loaded[2]; + let __v_128: G = __loaded[3]; + let __v_129: G = __loaded[4]; + let __v_130: G = __loaded[5]; + let __v_131: G = __loaded[6]; + let __v_132: G = __loaded[7]; + let __v_133: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_134: G = __r_arr[0]; + let __v_135: G = __r_arr[1]; + let __v_136: G = __r_arr[2]; + let __v_137: G = __r_arr[3]; + let __v_138: G = __r_arr[4]; + let __v_139: G = __r_arr[5]; + let __v_140: G = __r_arr[6]; + let __v_141: G = __r_arr[7]; + let __v_142: G = __r_arr[8]; + let __v_143: G = __r_arr[9]; + let __v_144: G = __r_arr[10]; + let __v_145: G = __r_arr[11]; + let __v_146: G = __r_arr[12]; + let __v_147: G = __r_arr[13]; + let __v_148: G = __r_arr[14]; + let __v_149: G = __r_arr[15]; + let __v_150: G = __r_arr[16]; + let __v_151: G = __r_arr[17]; + let __v_152: G = __r_arr[18]; + let __v_153: G = __r_arr[19]; + let __v_154: G = __r_arr[20]; + let __v_155: G = __r_arr[21]; + let __v_156: G = __r_arr[22]; + let __v_157: G = __r_arr[23]; + let __v_158: G = __r_arr[24]; + let __v_159: G = __r_arr[25]; + let __v_160: G = __r_arr[26]; + let __v_161: G = __r_arr[27]; + let __v_162: G = __r_arr[28]; + let __v_163: G = __r_arr[29]; + let __v_164: G = __r_arr[30]; + let __v_165: G = __r_arr[31]; + let __v_166: G = G::from_u64(1); + let __v_167: G = G::from_u64(1); + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_169: G = G::from_u64(0); + let __v_170: G = G::from_u64(1); + let __v_171: G = (__v_2 + __v_170); + let __v_172: G = { let __values: [G; 32] = [__v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_173: G = __r_arr[0]; + let __ret: [G; OUT_27] = [__v_173]; + record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_28: usize = 24; +const IN_28: usize = 24; +const OUT_28: usize = 16; +fn aiur_fn_28( + inp: [G; IN_28], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_28], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_24: G = __b2_add.0; + let __v_25: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_26: G = __b2_add.0; + let __v_27: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_26, &__v_25); let mut __scratch: Vec = vec![__v_26, __v_25]; if unconstrained { __scratch.push(Bytes2::add(&__v_26, &__v_25).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_28: G = __b2_add.0; + let __v_29: G = __b2_add.1; + let __v_30: G = (__v_27 + __v_29); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_31: G = __b2_add.0; + let __v_32: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_31, &__v_30); let mut __scratch: Vec = vec![__v_31, __v_30]; if unconstrained { __scratch.push(Bytes2::add(&__v_31, &__v_30).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_33: G = __b2_add.0; + let __v_34: G = __b2_add.1; + let __v_35: G = (__v_32 + __v_34); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_36: G = __b2_add.0; + let __v_37: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_36, &__v_35); let mut __scratch: Vec = vec![__v_36, __v_35]; if unconstrained { __scratch.push(Bytes2::add(&__v_36, &__v_35).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_38: G = __b2_add.0; + let __v_39: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_24, &__v_16); let mut __scratch: Vec = vec![__v_24, __v_16]; if unconstrained { __scratch.push(Bytes2::add(&__v_24, &__v_16).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_40: G = __b2_add.0; + let __v_41: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_28, &__v_17); let mut __scratch: Vec = vec![__v_28, __v_17]; if unconstrained { __scratch.push(Bytes2::add(&__v_28, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_42: G = __b2_add.0; + let __v_43: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_42, &__v_41); let mut __scratch: Vec = vec![__v_42, __v_41]; if unconstrained { __scratch.push(Bytes2::add(&__v_42, &__v_41).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_44: G = __b2_add.0; + let __v_45: G = __b2_add.1; + let __v_46: G = (__v_43 + __v_45); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_33, &__v_18); let mut __scratch: Vec = vec![__v_33, __v_18]; if unconstrained { __scratch.push(Bytes2::add(&__v_33, &__v_18).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_47: G = __b2_add.0; + let __v_48: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_47, &__v_46); let mut __scratch: Vec = vec![__v_47, __v_46]; if unconstrained { __scratch.push(Bytes2::add(&__v_47, &__v_46).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_49: G = __b2_add.0; + let __v_50: G = __b2_add.1; + let __v_51: G = (__v_48 + __v_50); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_38, &__v_19); let mut __scratch: Vec = vec![__v_38, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_38, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_52: G = __b2_add.0; + let __v_53: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_52, &__v_51); let mut __scratch: Vec = vec![__v_52, __v_51]; if unconstrained { __scratch.push(Bytes2::add(&__v_52, &__v_51).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_54: G = __b2_add.0; + let __v_55: G = __b2_add.1; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_12, __v_40]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_12, &__v_40)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_56: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_13, __v_44]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_13, &__v_44)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_57: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_14, __v_49]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_14, &__v_49)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_58: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_15, __v_54]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_15, &__v_54)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_59: G = __b2_out[0]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_8, &__v_58); let mut __scratch: Vec = vec![__v_8, __v_58]; if unconstrained { __scratch.push(Bytes2::add(&__v_8, &__v_58).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_60: G = __b2_add.0; + let __v_61: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_9, &__v_59); let mut __scratch: Vec = vec![__v_9, __v_59]; if unconstrained { __scratch.push(Bytes2::add(&__v_9, &__v_59).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_62: G = __b2_add.0; + let __v_63: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_62, &__v_61); let mut __scratch: Vec = vec![__v_62, __v_61]; if unconstrained { __scratch.push(Bytes2::add(&__v_62, &__v_61).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_64: G = __b2_add.0; + let __v_65: G = __b2_add.1; + let __v_66: G = (__v_63 + __v_65); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_56); let mut __scratch: Vec = vec![__v_10, __v_56]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_56).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_67: G = __b2_add.0; + let __v_68: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_67, &__v_66); let mut __scratch: Vec = vec![__v_67, __v_66]; if unconstrained { __scratch.push(Bytes2::add(&__v_67, &__v_66).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_69: G = __b2_add.0; + let __v_70: G = __b2_add.1; + let __v_71: G = (__v_68 + __v_70); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_11, &__v_57); let mut __scratch: Vec = vec![__v_11, __v_57]; if unconstrained { __scratch.push(Bytes2::add(&__v_11, &__v_57).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_72: G = __b2_add.0; + let __v_73: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_72, &__v_71); let mut __scratch: Vec = vec![__v_72, __v_71]; if unconstrained { __scratch.push(Bytes2::add(&__v_72, &__v_71).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_74: G = __b2_add.0; + let __v_75: G = __b2_add.1; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_60]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_60)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_76: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_64]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_5, &__v_64)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_77: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_69]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_6, &__v_69)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_78: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_74]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_7, &__v_74)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_79: G = __b2_out[0]; + let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_77, __v_78]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr4(&__v_77, &__v_78).0, Bytes2::chain_rotr4(&__v_77, &__v_78).1, Bytes2::chain_rotr4(&__v_77, &__v_78).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr4, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_80: G = __b2_out[0]; + let __v_81: G = __b2_out[1]; + let __v_82: G = __b2_out[2]; + let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_79, __v_76]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr4(&__v_79, &__v_76).0, Bytes2::chain_rotr4(&__v_79, &__v_76).1, Bytes2::chain_rotr4(&__v_79, &__v_76).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr4, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_83: G = __b2_out[0]; + let __v_84: G = __b2_out[1]; + let __v_85: G = __b2_out[2]; + let __v_86: G = (__v_81 + __v_85); + let __v_87: G = (__v_84 + __v_82); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_40, &__v_80); let mut __scratch: Vec = vec![__v_40, __v_80]; if unconstrained { __scratch.push(Bytes2::add(&__v_40, &__v_80).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_88: G = __b2_add.0; + let __v_89: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_44, &__v_86); let mut __scratch: Vec = vec![__v_44, __v_86]; if unconstrained { __scratch.push(Bytes2::add(&__v_44, &__v_86).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_90: G = __b2_add.0; + let __v_91: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_90, &__v_89); let mut __scratch: Vec = vec![__v_90, __v_89]; if unconstrained { __scratch.push(Bytes2::add(&__v_90, &__v_89).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_92: G = __b2_add.0; + let __v_93: G = __b2_add.1; + let __v_94: G = (__v_91 + __v_93); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_49, &__v_83); let mut __scratch: Vec = vec![__v_49, __v_83]; if unconstrained { __scratch.push(Bytes2::add(&__v_49, &__v_83).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_95: G = __b2_add.0; + let __v_96: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_95, &__v_94); let mut __scratch: Vec = vec![__v_95, __v_94]; if unconstrained { __scratch.push(Bytes2::add(&__v_95, &__v_94).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_97: G = __b2_add.0; + let __v_98: G = __b2_add.1; + let __v_99: G = (__v_96 + __v_98); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_54, &__v_87); let mut __scratch: Vec = vec![__v_54, __v_87]; if unconstrained { __scratch.push(Bytes2::add(&__v_54, &__v_87).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_100: G = __b2_add.0; + let __v_101: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_100, &__v_99); let mut __scratch: Vec = vec![__v_100, __v_99]; if unconstrained { __scratch.push(Bytes2::add(&__v_100, &__v_99).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_102: G = __b2_add.0; + let __v_103: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_88, &__v_20); let mut __scratch: Vec = vec![__v_88, __v_20]; if unconstrained { __scratch.push(Bytes2::add(&__v_88, &__v_20).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_104: G = __b2_add.0; + let __v_105: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_92, &__v_21); let mut __scratch: Vec = vec![__v_92, __v_21]; if unconstrained { __scratch.push(Bytes2::add(&__v_92, &__v_21).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_106: G = __b2_add.0; + let __v_107: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_106, &__v_105); let mut __scratch: Vec = vec![__v_106, __v_105]; if unconstrained { __scratch.push(Bytes2::add(&__v_106, &__v_105).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_108: G = __b2_add.0; + let __v_109: G = __b2_add.1; + let __v_110: G = (__v_107 + __v_109); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_97, &__v_22); let mut __scratch: Vec = vec![__v_97, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_97, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_111: G = __b2_add.0; + let __v_112: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_111, &__v_110); let mut __scratch: Vec = vec![__v_111, __v_110]; if unconstrained { __scratch.push(Bytes2::add(&__v_111, &__v_110).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_113: G = __b2_add.0; + let __v_114: G = __b2_add.1; + let __v_115: G = (__v_112 + __v_114); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_102, &__v_23); let mut __scratch: Vec = vec![__v_102, __v_23]; if unconstrained { __scratch.push(Bytes2::add(&__v_102, &__v_23).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_116: G = __b2_add.0; + let __v_117: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_116, &__v_115); let mut __scratch: Vec = vec![__v_116, __v_115]; if unconstrained { __scratch.push(Bytes2::add(&__v_116, &__v_115).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_118: G = __b2_add.0; + let __v_119: G = __b2_add.1; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_58, __v_104]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_58, &__v_104)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_120: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_59, __v_108]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_59, &__v_108)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_121: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_56, __v_113]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_56, &__v_113)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_122: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_57, __v_118]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_57, &__v_118)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_123: G = __b2_out[0]; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_60, &__v_121); let mut __scratch: Vec = vec![__v_60, __v_121]; if unconstrained { __scratch.push(Bytes2::add(&__v_60, &__v_121).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_124: G = __b2_add.0; + let __v_125: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_64, &__v_122); let mut __scratch: Vec = vec![__v_64, __v_122]; if unconstrained { __scratch.push(Bytes2::add(&__v_64, &__v_122).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_126: G = __b2_add.0; + let __v_127: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_126, &__v_125); let mut __scratch: Vec = vec![__v_126, __v_125]; if unconstrained { __scratch.push(Bytes2::add(&__v_126, &__v_125).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_128: G = __b2_add.0; + let __v_129: G = __b2_add.1; + let __v_130: G = (__v_127 + __v_129); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_69, &__v_123); let mut __scratch: Vec = vec![__v_69, __v_123]; if unconstrained { __scratch.push(Bytes2::add(&__v_69, &__v_123).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_131: G = __b2_add.0; + let __v_132: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_131, &__v_130); let mut __scratch: Vec = vec![__v_131, __v_130]; if unconstrained { __scratch.push(Bytes2::add(&__v_131, &__v_130).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_133: G = __b2_add.0; + let __v_134: G = __b2_add.1; + let __v_135: G = (__v_132 + __v_134); + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_74, &__v_120); let mut __scratch: Vec = vec![__v_74, __v_120]; if unconstrained { __scratch.push(Bytes2::add(&__v_74, &__v_120).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_136: G = __b2_add.0; + let __v_137: G = __b2_add.1; + let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_136, &__v_135); let mut __scratch: Vec = vec![__v_136, __v_135]; if unconstrained { __scratch.push(Bytes2::add(&__v_136, &__v_135).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_138: G = __b2_add.0; + let __v_139: G = __b2_add.1; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_80, __v_124]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_80, &__v_124)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_140: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_86, __v_128]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_86, &__v_128)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_141: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_83, __v_133]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_83, &__v_133)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_142: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_87, __v_138]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_87, &__v_138)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_143: G = __b2_out[0]; + let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_140, __v_141]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr7(&__v_140, &__v_141).0, Bytes2::chain_rotr7(&__v_140, &__v_141).1, Bytes2::chain_rotr7(&__v_140, &__v_141).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr7, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_144: G = __b2_out[0]; + let __v_145: G = __b2_out[1]; + let __v_146: G = __b2_out[2]; + let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_142, __v_143]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr7(&__v_142, &__v_143).0, Bytes2::chain_rotr7(&__v_142, &__v_143).1, Bytes2::chain_rotr7(&__v_142, &__v_143).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr7, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_147: G = __b2_out[0]; + let __v_148: G = __b2_out[1]; + let __v_149: G = __b2_out[2]; + let __v_150: G = (__v_145 + __v_149); + let __v_151: G = (__v_148 + __v_146); + let __ret: [G; OUT_28] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; + record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_29: usize = 128; +const IN_29: usize = 128; +const OUT_29: usize = 128; +fn aiur_fn_29( + inp: [G; IN_29], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_29], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + let __v_99: G = inp[99]; + let __v_100: G = inp[100]; + let __v_101: G = inp[101]; + let __v_102: G = inp[102]; + let __v_103: G = inp[103]; + let __v_104: G = inp[104]; + let __v_105: G = inp[105]; + let __v_106: G = inp[106]; + let __v_107: G = inp[107]; + let __v_108: G = inp[108]; + let __v_109: G = inp[109]; + let __v_110: G = inp[110]; + let __v_111: G = inp[111]; + let __v_112: G = inp[112]; + let __v_113: G = inp[113]; + let __v_114: G = inp[114]; + let __v_115: G = inp[115]; + let __v_116: G = inp[116]; + let __v_117: G = inp[117]; + let __v_118: G = inp[118]; + let __v_119: G = inp[119]; + let __v_120: G = inp[120]; + let __v_121: G = inp[121]; + let __v_122: G = inp[122]; + let __v_123: G = inp[123]; + let __v_124: G = inp[124]; + let __v_125: G = inp[125]; + let __v_126: G = inp[126]; + let __v_127: G = inp[127]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = __r_arr[6]; + let __v_135: G = __r_arr[7]; + let __v_136: G = __r_arr[8]; + let __v_137: G = __r_arr[9]; + let __v_138: G = __r_arr[10]; + let __v_139: G = __r_arr[11]; + let __v_140: G = __r_arr[12]; + let __v_141: G = __r_arr[13]; + let __v_142: G = __r_arr[14]; + let __v_143: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_144: G = __r_arr[0]; + let __v_145: G = __r_arr[1]; + let __v_146: G = __r_arr[2]; + let __v_147: G = __r_arr[3]; + let __v_148: G = __r_arr[4]; + let __v_149: G = __r_arr[5]; + let __v_150: G = __r_arr[6]; + let __v_151: G = __r_arr[7]; + let __v_152: G = __r_arr[8]; + let __v_153: G = __r_arr[9]; + let __v_154: G = __r_arr[10]; + let __v_155: G = __r_arr[11]; + let __v_156: G = __r_arr[12]; + let __v_157: G = __r_arr[13]; + let __v_158: G = __r_arr[14]; + let __v_159: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_160: G = __r_arr[0]; + let __v_161: G = __r_arr[1]; + let __v_162: G = __r_arr[2]; + let __v_163: G = __r_arr[3]; + let __v_164: G = __r_arr[4]; + let __v_165: G = __r_arr[5]; + let __v_166: G = __r_arr[6]; + let __v_167: G = __r_arr[7]; + let __v_168: G = __r_arr[8]; + let __v_169: G = __r_arr[9]; + let __v_170: G = __r_arr[10]; + let __v_171: G = __r_arr[11]; + let __v_172: G = __r_arr[12]; + let __v_173: G = __r_arr[13]; + let __v_174: G = __r_arr[14]; + let __v_175: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_176: G = __r_arr[0]; + let __v_177: G = __r_arr[1]; + let __v_178: G = __r_arr[2]; + let __v_179: G = __r_arr[3]; + let __v_180: G = __r_arr[4]; + let __v_181: G = __r_arr[5]; + let __v_182: G = __r_arr[6]; + let __v_183: G = __r_arr[7]; + let __v_184: G = __r_arr[8]; + let __v_185: G = __r_arr[9]; + let __v_186: G = __r_arr[10]; + let __v_187: G = __r_arr[11]; + let __v_188: G = __r_arr[12]; + let __v_189: G = __r_arr[13]; + let __v_190: G = __r_arr[14]; + let __v_191: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_192: G = __r_arr[0]; + let __v_193: G = __r_arr[1]; + let __v_194: G = __r_arr[2]; + let __v_195: G = __r_arr[3]; + let __v_196: G = __r_arr[4]; + let __v_197: G = __r_arr[5]; + let __v_198: G = __r_arr[6]; + let __v_199: G = __r_arr[7]; + let __v_200: G = __r_arr[8]; + let __v_201: G = __r_arr[9]; + let __v_202: G = __r_arr[10]; + let __v_203: G = __r_arr[11]; + let __v_204: G = __r_arr[12]; + let __v_205: G = __r_arr[13]; + let __v_206: G = __r_arr[14]; + let __v_207: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_208: G = __r_arr[0]; + let __v_209: G = __r_arr[1]; + let __v_210: G = __r_arr[2]; + let __v_211: G = __r_arr[3]; + let __v_212: G = __r_arr[4]; + let __v_213: G = __r_arr[5]; + let __v_214: G = __r_arr[6]; + let __v_215: G = __r_arr[7]; + let __v_216: G = __r_arr[8]; + let __v_217: G = __r_arr[9]; + let __v_218: G = __r_arr[10]; + let __v_219: G = __r_arr[11]; + let __v_220: G = __r_arr[12]; + let __v_221: G = __r_arr[13]; + let __v_222: G = __r_arr[14]; + let __v_223: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_224: G = __r_arr[0]; + let __v_225: G = __r_arr[1]; + let __v_226: G = __r_arr[2]; + let __v_227: G = __r_arr[3]; + let __v_228: G = __r_arr[4]; + let __v_229: G = __r_arr[5]; + let __v_230: G = __r_arr[6]; + let __v_231: G = __r_arr[7]; + let __v_232: G = __r_arr[8]; + let __v_233: G = __r_arr[9]; + let __v_234: G = __r_arr[10]; + let __v_235: G = __r_arr[11]; + let __v_236: G = __r_arr[12]; + let __v_237: G = __r_arr[13]; + let __v_238: G = __r_arr[14]; + let __v_239: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __v_240: G = __r_arr[0]; + let __v_241: G = __r_arr[1]; + let __v_242: G = __r_arr[2]; + let __v_243: G = __r_arr[3]; + let __v_244: G = __r_arr[4]; + let __v_245: G = __r_arr[5]; + let __v_246: G = __r_arr[6]; + let __v_247: G = __r_arr[7]; + let __v_248: G = __r_arr[8]; + let __v_249: G = __r_arr[9]; + let __v_250: G = __r_arr[10]; + let __v_251: G = __r_arr[11]; + let __v_252: G = __r_arr[12]; + let __v_253: G = __r_arr[13]; + let __v_254: G = __r_arr[14]; + let __v_255: G = __r_arr[15]; + let __ret: [G; OUT_29] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; + record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_30: usize = 106; +const IN_30: usize = 106; +const OUT_30: usize = 32; +fn aiur_fn_30( + inp: [G; IN_30], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_30], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + let __v_99: G = inp[99]; + let __v_100: G = inp[100]; + let __v_101: G = inp[101]; + let __v_102: G = inp[102]; + let __v_103: G = inp[103]; + let __v_104: G = inp[104]; + let __v_105: G = inp[105]; + let __v_106: G = G::from_u64(103); + let __v_107: G = G::from_u64(230); + let __v_108: G = G::from_u64(9); + let __v_109: G = G::from_u64(106); + let __v_110: G = G::from_u64(133); + let __v_111: G = G::from_u64(174); + let __v_112: G = G::from_u64(103); + let __v_113: G = G::from_u64(187); + let __v_114: G = G::from_u64(114); + let __v_115: G = G::from_u64(243); + let __v_116: G = G::from_u64(110); + let __v_117: G = G::from_u64(60); + let __v_118: G = G::from_u64(58); + let __v_119: G = G::from_u64(245); + let __v_120: G = G::from_u64(79); + let __v_121: G = G::from_u64(165); + let __v_122: G = G::from_u64(0); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = G::from_u64(0); + let __v_126: G = G::from_u64(0); + let __v_127: G = G::from_u64(0); + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = __r_arr[6]; + let __v_135: G = __r_arr[7]; + let __v_136: G = __r_arr[8]; + let __v_137: G = __r_arr[9]; + let __v_138: G = __r_arr[10]; + let __v_139: G = __r_arr[11]; + let __v_140: G = __r_arr[12]; + let __v_141: G = __r_arr[13]; + let __v_142: G = __r_arr[14]; + let __v_143: G = __r_arr[15]; + let __v_144: G = __r_arr[16]; + let __v_145: G = __r_arr[17]; + let __v_146: G = __r_arr[18]; + let __v_147: G = __r_arr[19]; + let __v_148: G = __r_arr[20]; + let __v_149: G = __r_arr[21]; + let __v_150: G = __r_arr[22]; + let __v_151: G = __r_arr[23]; + let __v_152: G = __r_arr[24]; + let __v_153: G = __r_arr[25]; + let __v_154: G = __r_arr[26]; + let __v_155: G = __r_arr[27]; + let __v_156: G = __r_arr[28]; + let __v_157: G = __r_arr[29]; + let __v_158: G = __r_arr[30]; + let __v_159: G = __r_arr[31]; + let __v_160: G = __r_arr[32]; + let __v_161: G = __r_arr[33]; + let __v_162: G = __r_arr[34]; + let __v_163: G = __r_arr[35]; + let __v_164: G = __r_arr[36]; + let __v_165: G = __r_arr[37]; + let __v_166: G = __r_arr[38]; + let __v_167: G = __r_arr[39]; + let __v_168: G = __r_arr[40]; + let __v_169: G = __r_arr[41]; + let __v_170: G = __r_arr[42]; + let __v_171: G = __r_arr[43]; + let __v_172: G = __r_arr[44]; + let __v_173: G = __r_arr[45]; + let __v_174: G = __r_arr[46]; + let __v_175: G = __r_arr[47]; + let __v_176: G = __r_arr[48]; + let __v_177: G = __r_arr[49]; + let __v_178: G = __r_arr[50]; + let __v_179: G = __r_arr[51]; + let __v_180: G = __r_arr[52]; + let __v_181: G = __r_arr[53]; + let __v_182: G = __r_arr[54]; + let __v_183: G = __r_arr[55]; + let __v_184: G = __r_arr[56]; + let __v_185: G = __r_arr[57]; + let __v_186: G = __r_arr[58]; + let __v_187: G = __r_arr[59]; + let __v_188: G = __r_arr[60]; + let __v_189: G = __r_arr[61]; + let __v_190: G = __r_arr[62]; + let __v_191: G = __r_arr[63]; + let __v_192: G = __r_arr[64]; + let __v_193: G = __r_arr[65]; + let __v_194: G = __r_arr[66]; + let __v_195: G = __r_arr[67]; + let __v_196: G = __r_arr[68]; + let __v_197: G = __r_arr[69]; + let __v_198: G = __r_arr[70]; + let __v_199: G = __r_arr[71]; + let __v_200: G = __r_arr[72]; + let __v_201: G = __r_arr[73]; + let __v_202: G = __r_arr[74]; + let __v_203: G = __r_arr[75]; + let __v_204: G = __r_arr[76]; + let __v_205: G = __r_arr[77]; + let __v_206: G = __r_arr[78]; + let __v_207: G = __r_arr[79]; + let __v_208: G = __r_arr[80]; + let __v_209: G = __r_arr[81]; + let __v_210: G = __r_arr[82]; + let __v_211: G = __r_arr[83]; + let __v_212: G = __r_arr[84]; + let __v_213: G = __r_arr[85]; + let __v_214: G = __r_arr[86]; + let __v_215: G = __r_arr[87]; + let __v_216: G = __r_arr[88]; + let __v_217: G = __r_arr[89]; + let __v_218: G = __r_arr[90]; + let __v_219: G = __r_arr[91]; + let __v_220: G = __r_arr[92]; + let __v_221: G = __r_arr[93]; + let __v_222: G = __r_arr[94]; + let __v_223: G = __r_arr[95]; + let __v_224: G = __r_arr[96]; + let __v_225: G = __r_arr[97]; + let __v_226: G = __r_arr[98]; + let __v_227: G = __r_arr[99]; + let __v_228: G = __r_arr[100]; + let __v_229: G = __r_arr[101]; + let __v_230: G = __r_arr[102]; + let __v_231: G = __r_arr[103]; + let __v_232: G = __r_arr[104]; + let __v_233: G = __r_arr[105]; + let __v_234: G = __r_arr[106]; + let __v_235: G = __r_arr[107]; + let __v_236: G = __r_arr[108]; + let __v_237: G = __r_arr[109]; + let __v_238: G = __r_arr[110]; + let __v_239: G = __r_arr[111]; + let __v_240: G = __r_arr[112]; + let __v_241: G = __r_arr[113]; + let __v_242: G = __r_arr[114]; + let __v_243: G = __r_arr[115]; + let __v_244: G = __r_arr[116]; + let __v_245: G = __r_arr[117]; + let __v_246: G = __r_arr[118]; + let __v_247: G = __r_arr[119]; + let __v_248: G = __r_arr[120]; + let __v_249: G = __r_arr[121]; + let __v_250: G = __r_arr[122]; + let __v_251: G = __r_arr[123]; + let __v_252: G = __r_arr[124]; + let __v_253: G = __r_arr[125]; + let __v_254: G = __r_arr[126]; + let __v_255: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_256: G = __r_arr[0]; + let __v_257: G = __r_arr[1]; + let __v_258: G = __r_arr[2]; + let __v_259: G = __r_arr[3]; + let __v_260: G = __r_arr[4]; + let __v_261: G = __r_arr[5]; + let __v_262: G = __r_arr[6]; + let __v_263: G = __r_arr[7]; + let __v_264: G = __r_arr[8]; + let __v_265: G = __r_arr[9]; + let __v_266: G = __r_arr[10]; + let __v_267: G = __r_arr[11]; + let __v_268: G = __r_arr[12]; + let __v_269: G = __r_arr[13]; + let __v_270: G = __r_arr[14]; + let __v_271: G = __r_arr[15]; + let __v_272: G = __r_arr[16]; + let __v_273: G = __r_arr[17]; + let __v_274: G = __r_arr[18]; + let __v_275: G = __r_arr[19]; + let __v_276: G = __r_arr[20]; + let __v_277: G = __r_arr[21]; + let __v_278: G = __r_arr[22]; + let __v_279: G = __r_arr[23]; + let __v_280: G = __r_arr[24]; + let __v_281: G = __r_arr[25]; + let __v_282: G = __r_arr[26]; + let __v_283: G = __r_arr[27]; + let __v_284: G = __r_arr[28]; + let __v_285: G = __r_arr[29]; + let __v_286: G = __r_arr[30]; + let __v_287: G = __r_arr[31]; + let __v_288: G = __r_arr[32]; + let __v_289: G = __r_arr[33]; + let __v_290: G = __r_arr[34]; + let __v_291: G = __r_arr[35]; + let __v_292: G = __r_arr[36]; + let __v_293: G = __r_arr[37]; + let __v_294: G = __r_arr[38]; + let __v_295: G = __r_arr[39]; + let __v_296: G = __r_arr[40]; + let __v_297: G = __r_arr[41]; + let __v_298: G = __r_arr[42]; + let __v_299: G = __r_arr[43]; + let __v_300: G = __r_arr[44]; + let __v_301: G = __r_arr[45]; + let __v_302: G = __r_arr[46]; + let __v_303: G = __r_arr[47]; + let __v_304: G = __r_arr[48]; + let __v_305: G = __r_arr[49]; + let __v_306: G = __r_arr[50]; + let __v_307: G = __r_arr[51]; + let __v_308: G = __r_arr[52]; + let __v_309: G = __r_arr[53]; + let __v_310: G = __r_arr[54]; + let __v_311: G = __r_arr[55]; + let __v_312: G = __r_arr[56]; + let __v_313: G = __r_arr[57]; + let __v_314: G = __r_arr[58]; + let __v_315: G = __r_arr[59]; + let __v_316: G = __r_arr[60]; + let __v_317: G = __r_arr[61]; + let __v_318: G = __r_arr[62]; + let __v_319: G = __r_arr[63]; + let __v_320: G = __r_arr[64]; + let __v_321: G = __r_arr[65]; + let __v_322: G = __r_arr[66]; + let __v_323: G = __r_arr[67]; + let __v_324: G = __r_arr[68]; + let __v_325: G = __r_arr[69]; + let __v_326: G = __r_arr[70]; + let __v_327: G = __r_arr[71]; + let __v_328: G = __r_arr[72]; + let __v_329: G = __r_arr[73]; + let __v_330: G = __r_arr[74]; + let __v_331: G = __r_arr[75]; + let __v_332: G = __r_arr[76]; + let __v_333: G = __r_arr[77]; + let __v_334: G = __r_arr[78]; + let __v_335: G = __r_arr[79]; + let __v_336: G = __r_arr[80]; + let __v_337: G = __r_arr[81]; + let __v_338: G = __r_arr[82]; + let __v_339: G = __r_arr[83]; + let __v_340: G = __r_arr[84]; + let __v_341: G = __r_arr[85]; + let __v_342: G = __r_arr[86]; + let __v_343: G = __r_arr[87]; + let __v_344: G = __r_arr[88]; + let __v_345: G = __r_arr[89]; + let __v_346: G = __r_arr[90]; + let __v_347: G = __r_arr[91]; + let __v_348: G = __r_arr[92]; + let __v_349: G = __r_arr[93]; + let __v_350: G = __r_arr[94]; + let __v_351: G = __r_arr[95]; + let __v_352: G = __r_arr[96]; + let __v_353: G = __r_arr[97]; + let __v_354: G = __r_arr[98]; + let __v_355: G = __r_arr[99]; + let __v_356: G = __r_arr[100]; + let __v_357: G = __r_arr[101]; + let __v_358: G = __r_arr[102]; + let __v_359: G = __r_arr[103]; + let __v_360: G = __r_arr[104]; + let __v_361: G = __r_arr[105]; + let __v_362: G = __r_arr[106]; + let __v_363: G = __r_arr[107]; + let __v_364: G = __r_arr[108]; + let __v_365: G = __r_arr[109]; + let __v_366: G = __r_arr[110]; + let __v_367: G = __r_arr[111]; + let __v_368: G = __r_arr[112]; + let __v_369: G = __r_arr[113]; + let __v_370: G = __r_arr[114]; + let __v_371: G = __r_arr[115]; + let __v_372: G = __r_arr[116]; + let __v_373: G = __r_arr[117]; + let __v_374: G = __r_arr[118]; + let __v_375: G = __r_arr[119]; + let __v_376: G = __r_arr[120]; + let __v_377: G = __r_arr[121]; + let __v_378: G = __r_arr[122]; + let __v_379: G = __r_arr[123]; + let __v_380: G = __r_arr[124]; + let __v_381: G = __r_arr[125]; + let __v_382: G = __r_arr[126]; + let __v_383: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_384: G = __r_arr[0]; + let __v_385: G = __r_arr[1]; + let __v_386: G = __r_arr[2]; + let __v_387: G = __r_arr[3]; + let __v_388: G = __r_arr[4]; + let __v_389: G = __r_arr[5]; + let __v_390: G = __r_arr[6]; + let __v_391: G = __r_arr[7]; + let __v_392: G = __r_arr[8]; + let __v_393: G = __r_arr[9]; + let __v_394: G = __r_arr[10]; + let __v_395: G = __r_arr[11]; + let __v_396: G = __r_arr[12]; + let __v_397: G = __r_arr[13]; + let __v_398: G = __r_arr[14]; + let __v_399: G = __r_arr[15]; + let __v_400: G = __r_arr[16]; + let __v_401: G = __r_arr[17]; + let __v_402: G = __r_arr[18]; + let __v_403: G = __r_arr[19]; + let __v_404: G = __r_arr[20]; + let __v_405: G = __r_arr[21]; + let __v_406: G = __r_arr[22]; + let __v_407: G = __r_arr[23]; + let __v_408: G = __r_arr[24]; + let __v_409: G = __r_arr[25]; + let __v_410: G = __r_arr[26]; + let __v_411: G = __r_arr[27]; + let __v_412: G = __r_arr[28]; + let __v_413: G = __r_arr[29]; + let __v_414: G = __r_arr[30]; + let __v_415: G = __r_arr[31]; + let __v_416: G = __r_arr[32]; + let __v_417: G = __r_arr[33]; + let __v_418: G = __r_arr[34]; + let __v_419: G = __r_arr[35]; + let __v_420: G = __r_arr[36]; + let __v_421: G = __r_arr[37]; + let __v_422: G = __r_arr[38]; + let __v_423: G = __r_arr[39]; + let __v_424: G = __r_arr[40]; + let __v_425: G = __r_arr[41]; + let __v_426: G = __r_arr[42]; + let __v_427: G = __r_arr[43]; + let __v_428: G = __r_arr[44]; + let __v_429: G = __r_arr[45]; + let __v_430: G = __r_arr[46]; + let __v_431: G = __r_arr[47]; + let __v_432: G = __r_arr[48]; + let __v_433: G = __r_arr[49]; + let __v_434: G = __r_arr[50]; + let __v_435: G = __r_arr[51]; + let __v_436: G = __r_arr[52]; + let __v_437: G = __r_arr[53]; + let __v_438: G = __r_arr[54]; + let __v_439: G = __r_arr[55]; + let __v_440: G = __r_arr[56]; + let __v_441: G = __r_arr[57]; + let __v_442: G = __r_arr[58]; + let __v_443: G = __r_arr[59]; + let __v_444: G = __r_arr[60]; + let __v_445: G = __r_arr[61]; + let __v_446: G = __r_arr[62]; + let __v_447: G = __r_arr[63]; + let __v_448: G = __r_arr[64]; + let __v_449: G = __r_arr[65]; + let __v_450: G = __r_arr[66]; + let __v_451: G = __r_arr[67]; + let __v_452: G = __r_arr[68]; + let __v_453: G = __r_arr[69]; + let __v_454: G = __r_arr[70]; + let __v_455: G = __r_arr[71]; + let __v_456: G = __r_arr[72]; + let __v_457: G = __r_arr[73]; + let __v_458: G = __r_arr[74]; + let __v_459: G = __r_arr[75]; + let __v_460: G = __r_arr[76]; + let __v_461: G = __r_arr[77]; + let __v_462: G = __r_arr[78]; + let __v_463: G = __r_arr[79]; + let __v_464: G = __r_arr[80]; + let __v_465: G = __r_arr[81]; + let __v_466: G = __r_arr[82]; + let __v_467: G = __r_arr[83]; + let __v_468: G = __r_arr[84]; + let __v_469: G = __r_arr[85]; + let __v_470: G = __r_arr[86]; + let __v_471: G = __r_arr[87]; + let __v_472: G = __r_arr[88]; + let __v_473: G = __r_arr[89]; + let __v_474: G = __r_arr[90]; + let __v_475: G = __r_arr[91]; + let __v_476: G = __r_arr[92]; + let __v_477: G = __r_arr[93]; + let __v_478: G = __r_arr[94]; + let __v_479: G = __r_arr[95]; + let __v_480: G = __r_arr[96]; + let __v_481: G = __r_arr[97]; + let __v_482: G = __r_arr[98]; + let __v_483: G = __r_arr[99]; + let __v_484: G = __r_arr[100]; + let __v_485: G = __r_arr[101]; + let __v_486: G = __r_arr[102]; + let __v_487: G = __r_arr[103]; + let __v_488: G = __r_arr[104]; + let __v_489: G = __r_arr[105]; + let __v_490: G = __r_arr[106]; + let __v_491: G = __r_arr[107]; + let __v_492: G = __r_arr[108]; + let __v_493: G = __r_arr[109]; + let __v_494: G = __r_arr[110]; + let __v_495: G = __r_arr[111]; + let __v_496: G = __r_arr[112]; + let __v_497: G = __r_arr[113]; + let __v_498: G = __r_arr[114]; + let __v_499: G = __r_arr[115]; + let __v_500: G = __r_arr[116]; + let __v_501: G = __r_arr[117]; + let __v_502: G = __r_arr[118]; + let __v_503: G = __r_arr[119]; + let __v_504: G = __r_arr[120]; + let __v_505: G = __r_arr[121]; + let __v_506: G = __r_arr[122]; + let __v_507: G = __r_arr[123]; + let __v_508: G = __r_arr[124]; + let __v_509: G = __r_arr[125]; + let __v_510: G = __r_arr[126]; + let __v_511: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_512: G = __r_arr[0]; + let __v_513: G = __r_arr[1]; + let __v_514: G = __r_arr[2]; + let __v_515: G = __r_arr[3]; + let __v_516: G = __r_arr[4]; + let __v_517: G = __r_arr[5]; + let __v_518: G = __r_arr[6]; + let __v_519: G = __r_arr[7]; + let __v_520: G = __r_arr[8]; + let __v_521: G = __r_arr[9]; + let __v_522: G = __r_arr[10]; + let __v_523: G = __r_arr[11]; + let __v_524: G = __r_arr[12]; + let __v_525: G = __r_arr[13]; + let __v_526: G = __r_arr[14]; + let __v_527: G = __r_arr[15]; + let __v_528: G = __r_arr[16]; + let __v_529: G = __r_arr[17]; + let __v_530: G = __r_arr[18]; + let __v_531: G = __r_arr[19]; + let __v_532: G = __r_arr[20]; + let __v_533: G = __r_arr[21]; + let __v_534: G = __r_arr[22]; + let __v_535: G = __r_arr[23]; + let __v_536: G = __r_arr[24]; + let __v_537: G = __r_arr[25]; + let __v_538: G = __r_arr[26]; + let __v_539: G = __r_arr[27]; + let __v_540: G = __r_arr[28]; + let __v_541: G = __r_arr[29]; + let __v_542: G = __r_arr[30]; + let __v_543: G = __r_arr[31]; + let __v_544: G = __r_arr[32]; + let __v_545: G = __r_arr[33]; + let __v_546: G = __r_arr[34]; + let __v_547: G = __r_arr[35]; + let __v_548: G = __r_arr[36]; + let __v_549: G = __r_arr[37]; + let __v_550: G = __r_arr[38]; + let __v_551: G = __r_arr[39]; + let __v_552: G = __r_arr[40]; + let __v_553: G = __r_arr[41]; + let __v_554: G = __r_arr[42]; + let __v_555: G = __r_arr[43]; + let __v_556: G = __r_arr[44]; + let __v_557: G = __r_arr[45]; + let __v_558: G = __r_arr[46]; + let __v_559: G = __r_arr[47]; + let __v_560: G = __r_arr[48]; + let __v_561: G = __r_arr[49]; + let __v_562: G = __r_arr[50]; + let __v_563: G = __r_arr[51]; + let __v_564: G = __r_arr[52]; + let __v_565: G = __r_arr[53]; + let __v_566: G = __r_arr[54]; + let __v_567: G = __r_arr[55]; + let __v_568: G = __r_arr[56]; + let __v_569: G = __r_arr[57]; + let __v_570: G = __r_arr[58]; + let __v_571: G = __r_arr[59]; + let __v_572: G = __r_arr[60]; + let __v_573: G = __r_arr[61]; + let __v_574: G = __r_arr[62]; + let __v_575: G = __r_arr[63]; + let __v_576: G = __r_arr[64]; + let __v_577: G = __r_arr[65]; + let __v_578: G = __r_arr[66]; + let __v_579: G = __r_arr[67]; + let __v_580: G = __r_arr[68]; + let __v_581: G = __r_arr[69]; + let __v_582: G = __r_arr[70]; + let __v_583: G = __r_arr[71]; + let __v_584: G = __r_arr[72]; + let __v_585: G = __r_arr[73]; + let __v_586: G = __r_arr[74]; + let __v_587: G = __r_arr[75]; + let __v_588: G = __r_arr[76]; + let __v_589: G = __r_arr[77]; + let __v_590: G = __r_arr[78]; + let __v_591: G = __r_arr[79]; + let __v_592: G = __r_arr[80]; + let __v_593: G = __r_arr[81]; + let __v_594: G = __r_arr[82]; + let __v_595: G = __r_arr[83]; + let __v_596: G = __r_arr[84]; + let __v_597: G = __r_arr[85]; + let __v_598: G = __r_arr[86]; + let __v_599: G = __r_arr[87]; + let __v_600: G = __r_arr[88]; + let __v_601: G = __r_arr[89]; + let __v_602: G = __r_arr[90]; + let __v_603: G = __r_arr[91]; + let __v_604: G = __r_arr[92]; + let __v_605: G = __r_arr[93]; + let __v_606: G = __r_arr[94]; + let __v_607: G = __r_arr[95]; + let __v_608: G = __r_arr[96]; + let __v_609: G = __r_arr[97]; + let __v_610: G = __r_arr[98]; + let __v_611: G = __r_arr[99]; + let __v_612: G = __r_arr[100]; + let __v_613: G = __r_arr[101]; + let __v_614: G = __r_arr[102]; + let __v_615: G = __r_arr[103]; + let __v_616: G = __r_arr[104]; + let __v_617: G = __r_arr[105]; + let __v_618: G = __r_arr[106]; + let __v_619: G = __r_arr[107]; + let __v_620: G = __r_arr[108]; + let __v_621: G = __r_arr[109]; + let __v_622: G = __r_arr[110]; + let __v_623: G = __r_arr[111]; + let __v_624: G = __r_arr[112]; + let __v_625: G = __r_arr[113]; + let __v_626: G = __r_arr[114]; + let __v_627: G = __r_arr[115]; + let __v_628: G = __r_arr[116]; + let __v_629: G = __r_arr[117]; + let __v_630: G = __r_arr[118]; + let __v_631: G = __r_arr[119]; + let __v_632: G = __r_arr[120]; + let __v_633: G = __r_arr[121]; + let __v_634: G = __r_arr[122]; + let __v_635: G = __r_arr[123]; + let __v_636: G = __r_arr[124]; + let __v_637: G = __r_arr[125]; + let __v_638: G = __r_arr[126]; + let __v_639: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_640: G = __r_arr[0]; + let __v_641: G = __r_arr[1]; + let __v_642: G = __r_arr[2]; + let __v_643: G = __r_arr[3]; + let __v_644: G = __r_arr[4]; + let __v_645: G = __r_arr[5]; + let __v_646: G = __r_arr[6]; + let __v_647: G = __r_arr[7]; + let __v_648: G = __r_arr[8]; + let __v_649: G = __r_arr[9]; + let __v_650: G = __r_arr[10]; + let __v_651: G = __r_arr[11]; + let __v_652: G = __r_arr[12]; + let __v_653: G = __r_arr[13]; + let __v_654: G = __r_arr[14]; + let __v_655: G = __r_arr[15]; + let __v_656: G = __r_arr[16]; + let __v_657: G = __r_arr[17]; + let __v_658: G = __r_arr[18]; + let __v_659: G = __r_arr[19]; + let __v_660: G = __r_arr[20]; + let __v_661: G = __r_arr[21]; + let __v_662: G = __r_arr[22]; + let __v_663: G = __r_arr[23]; + let __v_664: G = __r_arr[24]; + let __v_665: G = __r_arr[25]; + let __v_666: G = __r_arr[26]; + let __v_667: G = __r_arr[27]; + let __v_668: G = __r_arr[28]; + let __v_669: G = __r_arr[29]; + let __v_670: G = __r_arr[30]; + let __v_671: G = __r_arr[31]; + let __v_672: G = __r_arr[32]; + let __v_673: G = __r_arr[33]; + let __v_674: G = __r_arr[34]; + let __v_675: G = __r_arr[35]; + let __v_676: G = __r_arr[36]; + let __v_677: G = __r_arr[37]; + let __v_678: G = __r_arr[38]; + let __v_679: G = __r_arr[39]; + let __v_680: G = __r_arr[40]; + let __v_681: G = __r_arr[41]; + let __v_682: G = __r_arr[42]; + let __v_683: G = __r_arr[43]; + let __v_684: G = __r_arr[44]; + let __v_685: G = __r_arr[45]; + let __v_686: G = __r_arr[46]; + let __v_687: G = __r_arr[47]; + let __v_688: G = __r_arr[48]; + let __v_689: G = __r_arr[49]; + let __v_690: G = __r_arr[50]; + let __v_691: G = __r_arr[51]; + let __v_692: G = __r_arr[52]; + let __v_693: G = __r_arr[53]; + let __v_694: G = __r_arr[54]; + let __v_695: G = __r_arr[55]; + let __v_696: G = __r_arr[56]; + let __v_697: G = __r_arr[57]; + let __v_698: G = __r_arr[58]; + let __v_699: G = __r_arr[59]; + let __v_700: G = __r_arr[60]; + let __v_701: G = __r_arr[61]; + let __v_702: G = __r_arr[62]; + let __v_703: G = __r_arr[63]; + let __v_704: G = __r_arr[64]; + let __v_705: G = __r_arr[65]; + let __v_706: G = __r_arr[66]; + let __v_707: G = __r_arr[67]; + let __v_708: G = __r_arr[68]; + let __v_709: G = __r_arr[69]; + let __v_710: G = __r_arr[70]; + let __v_711: G = __r_arr[71]; + let __v_712: G = __r_arr[72]; + let __v_713: G = __r_arr[73]; + let __v_714: G = __r_arr[74]; + let __v_715: G = __r_arr[75]; + let __v_716: G = __r_arr[76]; + let __v_717: G = __r_arr[77]; + let __v_718: G = __r_arr[78]; + let __v_719: G = __r_arr[79]; + let __v_720: G = __r_arr[80]; + let __v_721: G = __r_arr[81]; + let __v_722: G = __r_arr[82]; + let __v_723: G = __r_arr[83]; + let __v_724: G = __r_arr[84]; + let __v_725: G = __r_arr[85]; + let __v_726: G = __r_arr[86]; + let __v_727: G = __r_arr[87]; + let __v_728: G = __r_arr[88]; + let __v_729: G = __r_arr[89]; + let __v_730: G = __r_arr[90]; + let __v_731: G = __r_arr[91]; + let __v_732: G = __r_arr[92]; + let __v_733: G = __r_arr[93]; + let __v_734: G = __r_arr[94]; + let __v_735: G = __r_arr[95]; + let __v_736: G = __r_arr[96]; + let __v_737: G = __r_arr[97]; + let __v_738: G = __r_arr[98]; + let __v_739: G = __r_arr[99]; + let __v_740: G = __r_arr[100]; + let __v_741: G = __r_arr[101]; + let __v_742: G = __r_arr[102]; + let __v_743: G = __r_arr[103]; + let __v_744: G = __r_arr[104]; + let __v_745: G = __r_arr[105]; + let __v_746: G = __r_arr[106]; + let __v_747: G = __r_arr[107]; + let __v_748: G = __r_arr[108]; + let __v_749: G = __r_arr[109]; + let __v_750: G = __r_arr[110]; + let __v_751: G = __r_arr[111]; + let __v_752: G = __r_arr[112]; + let __v_753: G = __r_arr[113]; + let __v_754: G = __r_arr[114]; + let __v_755: G = __r_arr[115]; + let __v_756: G = __r_arr[116]; + let __v_757: G = __r_arr[117]; + let __v_758: G = __r_arr[118]; + let __v_759: G = __r_arr[119]; + let __v_760: G = __r_arr[120]; + let __v_761: G = __r_arr[121]; + let __v_762: G = __r_arr[122]; + let __v_763: G = __r_arr[123]; + let __v_764: G = __r_arr[124]; + let __v_765: G = __r_arr[125]; + let __v_766: G = __r_arr[126]; + let __v_767: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_768: G = __r_arr[0]; + let __v_769: G = __r_arr[1]; + let __v_770: G = __r_arr[2]; + let __v_771: G = __r_arr[3]; + let __v_772: G = __r_arr[4]; + let __v_773: G = __r_arr[5]; + let __v_774: G = __r_arr[6]; + let __v_775: G = __r_arr[7]; + let __v_776: G = __r_arr[8]; + let __v_777: G = __r_arr[9]; + let __v_778: G = __r_arr[10]; + let __v_779: G = __r_arr[11]; + let __v_780: G = __r_arr[12]; + let __v_781: G = __r_arr[13]; + let __v_782: G = __r_arr[14]; + let __v_783: G = __r_arr[15]; + let __v_784: G = __r_arr[16]; + let __v_785: G = __r_arr[17]; + let __v_786: G = __r_arr[18]; + let __v_787: G = __r_arr[19]; + let __v_788: G = __r_arr[20]; + let __v_789: G = __r_arr[21]; + let __v_790: G = __r_arr[22]; + let __v_791: G = __r_arr[23]; + let __v_792: G = __r_arr[24]; + let __v_793: G = __r_arr[25]; + let __v_794: G = __r_arr[26]; + let __v_795: G = __r_arr[27]; + let __v_796: G = __r_arr[28]; + let __v_797: G = __r_arr[29]; + let __v_798: G = __r_arr[30]; + let __v_799: G = __r_arr[31]; + let __v_800: G = __r_arr[32]; + let __v_801: G = __r_arr[33]; + let __v_802: G = __r_arr[34]; + let __v_803: G = __r_arr[35]; + let __v_804: G = __r_arr[36]; + let __v_805: G = __r_arr[37]; + let __v_806: G = __r_arr[38]; + let __v_807: G = __r_arr[39]; + let __v_808: G = __r_arr[40]; + let __v_809: G = __r_arr[41]; + let __v_810: G = __r_arr[42]; + let __v_811: G = __r_arr[43]; + let __v_812: G = __r_arr[44]; + let __v_813: G = __r_arr[45]; + let __v_814: G = __r_arr[46]; + let __v_815: G = __r_arr[47]; + let __v_816: G = __r_arr[48]; + let __v_817: G = __r_arr[49]; + let __v_818: G = __r_arr[50]; + let __v_819: G = __r_arr[51]; + let __v_820: G = __r_arr[52]; + let __v_821: G = __r_arr[53]; + let __v_822: G = __r_arr[54]; + let __v_823: G = __r_arr[55]; + let __v_824: G = __r_arr[56]; + let __v_825: G = __r_arr[57]; + let __v_826: G = __r_arr[58]; + let __v_827: G = __r_arr[59]; + let __v_828: G = __r_arr[60]; + let __v_829: G = __r_arr[61]; + let __v_830: G = __r_arr[62]; + let __v_831: G = __r_arr[63]; + let __v_832: G = __r_arr[64]; + let __v_833: G = __r_arr[65]; + let __v_834: G = __r_arr[66]; + let __v_835: G = __r_arr[67]; + let __v_836: G = __r_arr[68]; + let __v_837: G = __r_arr[69]; + let __v_838: G = __r_arr[70]; + let __v_839: G = __r_arr[71]; + let __v_840: G = __r_arr[72]; + let __v_841: G = __r_arr[73]; + let __v_842: G = __r_arr[74]; + let __v_843: G = __r_arr[75]; + let __v_844: G = __r_arr[76]; + let __v_845: G = __r_arr[77]; + let __v_846: G = __r_arr[78]; + let __v_847: G = __r_arr[79]; + let __v_848: G = __r_arr[80]; + let __v_849: G = __r_arr[81]; + let __v_850: G = __r_arr[82]; + let __v_851: G = __r_arr[83]; + let __v_852: G = __r_arr[84]; + let __v_853: G = __r_arr[85]; + let __v_854: G = __r_arr[86]; + let __v_855: G = __r_arr[87]; + let __v_856: G = __r_arr[88]; + let __v_857: G = __r_arr[89]; + let __v_858: G = __r_arr[90]; + let __v_859: G = __r_arr[91]; + let __v_860: G = __r_arr[92]; + let __v_861: G = __r_arr[93]; + let __v_862: G = __r_arr[94]; + let __v_863: G = __r_arr[95]; + let __v_864: G = __r_arr[96]; + let __v_865: G = __r_arr[97]; + let __v_866: G = __r_arr[98]; + let __v_867: G = __r_arr[99]; + let __v_868: G = __r_arr[100]; + let __v_869: G = __r_arr[101]; + let __v_870: G = __r_arr[102]; + let __v_871: G = __r_arr[103]; + let __v_872: G = __r_arr[104]; + let __v_873: G = __r_arr[105]; + let __v_874: G = __r_arr[106]; + let __v_875: G = __r_arr[107]; + let __v_876: G = __r_arr[108]; + let __v_877: G = __r_arr[109]; + let __v_878: G = __r_arr[110]; + let __v_879: G = __r_arr[111]; + let __v_880: G = __r_arr[112]; + let __v_881: G = __r_arr[113]; + let __v_882: G = __r_arr[114]; + let __v_883: G = __r_arr[115]; + let __v_884: G = __r_arr[116]; + let __v_885: G = __r_arr[117]; + let __v_886: G = __r_arr[118]; + let __v_887: G = __r_arr[119]; + let __v_888: G = __r_arr[120]; + let __v_889: G = __r_arr[121]; + let __v_890: G = __r_arr[122]; + let __v_891: G = __r_arr[123]; + let __v_892: G = __r_arr[124]; + let __v_893: G = __r_arr[125]; + let __v_894: G = __r_arr[126]; + let __v_895: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_896: G = __r_arr[0]; + let __v_897: G = __r_arr[1]; + let __v_898: G = __r_arr[2]; + let __v_899: G = __r_arr[3]; + let __v_900: G = __r_arr[4]; + let __v_901: G = __r_arr[5]; + let __v_902: G = __r_arr[6]; + let __v_903: G = __r_arr[7]; + let __v_904: G = __r_arr[8]; + let __v_905: G = __r_arr[9]; + let __v_906: G = __r_arr[10]; + let __v_907: G = __r_arr[11]; + let __v_908: G = __r_arr[12]; + let __v_909: G = __r_arr[13]; + let __v_910: G = __r_arr[14]; + let __v_911: G = __r_arr[15]; + let __v_912: G = __r_arr[16]; + let __v_913: G = __r_arr[17]; + let __v_914: G = __r_arr[18]; + let __v_915: G = __r_arr[19]; + let __v_916: G = __r_arr[20]; + let __v_917: G = __r_arr[21]; + let __v_918: G = __r_arr[22]; + let __v_919: G = __r_arr[23]; + let __v_920: G = __r_arr[24]; + let __v_921: G = __r_arr[25]; + let __v_922: G = __r_arr[26]; + let __v_923: G = __r_arr[27]; + let __v_924: G = __r_arr[28]; + let __v_925: G = __r_arr[29]; + let __v_926: G = __r_arr[30]; + let __v_927: G = __r_arr[31]; + let __v_928: G = __r_arr[32]; + let __v_929: G = __r_arr[33]; + let __v_930: G = __r_arr[34]; + let __v_931: G = __r_arr[35]; + let __v_932: G = __r_arr[36]; + let __v_933: G = __r_arr[37]; + let __v_934: G = __r_arr[38]; + let __v_935: G = __r_arr[39]; + let __v_936: G = __r_arr[40]; + let __v_937: G = __r_arr[41]; + let __v_938: G = __r_arr[42]; + let __v_939: G = __r_arr[43]; + let __v_940: G = __r_arr[44]; + let __v_941: G = __r_arr[45]; + let __v_942: G = __r_arr[46]; + let __v_943: G = __r_arr[47]; + let __v_944: G = __r_arr[48]; + let __v_945: G = __r_arr[49]; + let __v_946: G = __r_arr[50]; + let __v_947: G = __r_arr[51]; + let __v_948: G = __r_arr[52]; + let __v_949: G = __r_arr[53]; + let __v_950: G = __r_arr[54]; + let __v_951: G = __r_arr[55]; + let __v_952: G = __r_arr[56]; + let __v_953: G = __r_arr[57]; + let __v_954: G = __r_arr[58]; + let __v_955: G = __r_arr[59]; + let __v_956: G = __r_arr[60]; + let __v_957: G = __r_arr[61]; + let __v_958: G = __r_arr[62]; + let __v_959: G = __r_arr[63]; + let __v_960: G = __r_arr[64]; + let __v_961: G = __r_arr[65]; + let __v_962: G = __r_arr[66]; + let __v_963: G = __r_arr[67]; + let __v_964: G = __r_arr[68]; + let __v_965: G = __r_arr[69]; + let __v_966: G = __r_arr[70]; + let __v_967: G = __r_arr[71]; + let __v_968: G = __r_arr[72]; + let __v_969: G = __r_arr[73]; + let __v_970: G = __r_arr[74]; + let __v_971: G = __r_arr[75]; + let __v_972: G = __r_arr[76]; + let __v_973: G = __r_arr[77]; + let __v_974: G = __r_arr[78]; + let __v_975: G = __r_arr[79]; + let __v_976: G = __r_arr[80]; + let __v_977: G = __r_arr[81]; + let __v_978: G = __r_arr[82]; + let __v_979: G = __r_arr[83]; + let __v_980: G = __r_arr[84]; + let __v_981: G = __r_arr[85]; + let __v_982: G = __r_arr[86]; + let __v_983: G = __r_arr[87]; + let __v_984: G = __r_arr[88]; + let __v_985: G = __r_arr[89]; + let __v_986: G = __r_arr[90]; + let __v_987: G = __r_arr[91]; + let __v_988: G = __r_arr[92]; + let __v_989: G = __r_arr[93]; + let __v_990: G = __r_arr[94]; + let __v_991: G = __r_arr[95]; + let __v_992: G = __r_arr[96]; + let __v_993: G = __r_arr[97]; + let __v_994: G = __r_arr[98]; + let __v_995: G = __r_arr[99]; + let __v_996: G = __r_arr[100]; + let __v_997: G = __r_arr[101]; + let __v_998: G = __r_arr[102]; + let __v_999: G = __r_arr[103]; + let __v_1000: G = __r_arr[104]; + let __v_1001: G = __r_arr[105]; + let __v_1002: G = __r_arr[106]; + let __v_1003: G = __r_arr[107]; + let __v_1004: G = __r_arr[108]; + let __v_1005: G = __r_arr[109]; + let __v_1006: G = __r_arr[110]; + let __v_1007: G = __r_arr[111]; + let __v_1008: G = __r_arr[112]; + let __v_1009: G = __r_arr[113]; + let __v_1010: G = __r_arr[114]; + let __v_1011: G = __r_arr[115]; + let __v_1012: G = __r_arr[116]; + let __v_1013: G = __r_arr[117]; + let __v_1014: G = __r_arr[118]; + let __v_1015: G = __r_arr[119]; + let __v_1016: G = __r_arr[120]; + let __v_1017: G = __r_arr[121]; + let __v_1018: G = __r_arr[122]; + let __v_1019: G = __r_arr[123]; + let __v_1020: G = __r_arr[124]; + let __v_1021: G = __r_arr[125]; + let __v_1022: G = __r_arr[126]; + let __v_1023: G = __r_arr[127]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_896, __v_928]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_896, &__v_928)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1024: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_897, __v_929]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_897, &__v_929)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1025: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_898, __v_930]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_898, &__v_930)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1026: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_899, __v_931]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_899, &__v_931)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1027: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_900, __v_932]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_900, &__v_932)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1028: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_901, __v_933]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_901, &__v_933)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1029: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_902, __v_934]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_902, &__v_934)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1030: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_903, __v_935]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_903, &__v_935)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1031: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_904, __v_936]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_904, &__v_936)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1032: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_905, __v_937]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_905, &__v_937)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1033: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_906, __v_938]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_906, &__v_938)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1034: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_907, __v_939]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_907, &__v_939)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1035: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_908, __v_940]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_908, &__v_940)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1036: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_909, __v_941]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_909, &__v_941)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1037: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_910, __v_942]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_910, &__v_942)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1038: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_911, __v_943]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_911, &__v_943)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1039: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_912, __v_944]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_912, &__v_944)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1040: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_913, __v_945]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_913, &__v_945)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1041: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_914, __v_946]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_914, &__v_946)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1042: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_915, __v_947]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_915, &__v_947)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1043: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_916, __v_948]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_916, &__v_948)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1044: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_917, __v_949]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_917, &__v_949)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1045: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_918, __v_950]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_918, &__v_950)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1046: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_919, __v_951]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_919, &__v_951)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1047: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_920, __v_952]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_920, &__v_952)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1048: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_921, __v_953]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_921, &__v_953)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1049: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_922, __v_954]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_922, &__v_954)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1050: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_923, __v_955]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_923, &__v_955)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1051: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_924, __v_956]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_924, &__v_956)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1052: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_925, __v_957]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_925, &__v_957)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1053: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_926, __v_958]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_926, &__v_958)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1054: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_927, __v_959]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_927, &__v_959)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_1055: G = __b2_out[0]; + let __ret: [G; OUT_30] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; + record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_31: usize = 0; +const IN_31: usize = 0; +const OUT_31: usize = 22; +fn aiur_fn_31( + inp: [G; IN_31], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_31], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(5); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(10); + let __v_13: G = G::from_u64(100); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __v_22: G = G::from_u64(20); + let __v_23: G = G::from_u64(200); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __v_26: G = __r_arr[2]; + let __v_27: G = __r_arr[3]; + let __v_28: G = __r_arr[4]; + let __v_29: G = __r_arr[5]; + let __v_30: G = G::from_u64(5); + let __v_31: G = G::from_u64(50); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = __r_arr[3]; + let __v_36: G = __r_arr[4]; + let __v_37: G = __r_arr[5]; + let __v_38: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(10); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(20); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(10); + let __v_45: G = G::from_u64(100); + let __v_46: G = G::from_u64(1); + let __v_47: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __v_51: G = __r_arr[3]; + let __v_52: G = __r_arr[4]; + let __v_53: G = __r_arr[5]; + let __v_54: G = G::from_u64(10); + let __v_55: G = G::from_u64(999); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = G::from_u64(10); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(10); + let __v_66: G = G::from_u64(1); + let __v_67: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; + let __v_70: G = __r_arr[2]; + let __v_71: G = __r_arr[3]; + let __v_72: G = __r_arr[4]; + let __v_73: G = __r_arr[5]; + let __v_74: G = G::from_u64(2); + let __v_75: G = G::from_u64(20); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = __r_arr[1]; + let __v_78: G = __r_arr[2]; + let __v_79: G = __r_arr[3]; + let __v_80: G = __r_arr[4]; + let __v_81: G = __r_arr[5]; + let __v_82: G = G::from_u64(3); + let __v_83: G = G::from_u64(30); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __v_87: G = __r_arr[3]; + let __v_88: G = __r_arr[4]; + let __v_89: G = __r_arr[5]; + let __v_90: G = G::from_u64(4); + let __v_91: G = G::from_u64(40); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_92: G = __r_arr[0]; + let __v_93: G = __r_arr[1]; + let __v_94: G = __r_arr[2]; + let __v_95: G = __r_arr[3]; + let __v_96: G = __r_arr[4]; + let __v_97: G = __r_arr[5]; + let __v_98: G = G::from_u64(5); + let __v_99: G = G::from_u64(50); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_100: G = __r_arr[0]; + let __v_101: G = __r_arr[1]; + let __v_102: G = __r_arr[2]; + let __v_103: G = __r_arr[3]; + let __v_104: G = __r_arr[4]; + let __v_105: G = __r_arr[5]; + let __v_106: G = G::from_u64(1); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(2); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = G::from_u64(3); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __v_112: G = G::from_u64(4); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(5); + let __v_117: G = G::from_u64(50); + let __v_118: G = G::from_u64(1); + let __v_119: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_120: G = __r_arr[0]; + let __v_121: G = __r_arr[1]; + let __v_122: G = __r_arr[2]; + let __v_123: G = __r_arr[3]; + let __v_124: G = __r_arr[4]; + let __v_125: G = __r_arr[5]; + let __v_126: G = G::from_u64(4); + let __v_127: G = G::from_u64(40); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = G::from_u64(3); + let __v_135: G = G::from_u64(30); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_136: G = __r_arr[0]; + let __v_137: G = __r_arr[1]; + let __v_138: G = __r_arr[2]; + let __v_139: G = __r_arr[3]; + let __v_140: G = __r_arr[4]; + let __v_141: G = __r_arr[5]; + let __v_142: G = G::from_u64(2); + let __v_143: G = G::from_u64(20); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_144: G = __r_arr[0]; + let __v_145: G = __r_arr[1]; + let __v_146: G = __r_arr[2]; + let __v_147: G = __r_arr[3]; + let __v_148: G = __r_arr[4]; + let __v_149: G = __r_arr[5]; + let __v_150: G = G::from_u64(1); + let __v_151: G = G::from_u64(10); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_152: G = __r_arr[0]; + let __v_153: G = __r_arr[1]; + let __v_154: G = __r_arr[2]; + let __v_155: G = __r_arr[3]; + let __v_156: G = __r_arr[4]; + let __v_157: G = __r_arr[5]; + let __v_158: G = G::from_u64(1); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_159: G = __r_arr[0]; + let __v_160: G = G::from_u64(2); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_161: G = __r_arr[0]; + let __v_162: G = G::from_u64(3); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_163: G = __r_arr[0]; + let __v_164: G = G::from_u64(4); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_165: G = __r_arr[0]; + let __v_166: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_167: G = __r_arr[0]; + let __v_168: G = G::from_u64(50); + let __v_169: G = G::from_u64(500); + let __v_170: G = G::from_u64(1); + let __v_171: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_172: G = __r_arr[0]; + let __v_173: G = __r_arr[1]; + let __v_174: G = __r_arr[2]; + let __v_175: G = __r_arr[3]; + let __v_176: G = __r_arr[4]; + let __v_177: G = __r_arr[5]; + let __v_178: G = G::from_u64(30); + let __v_179: G = G::from_u64(300); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_180: G = __r_arr[0]; + let __v_181: G = __r_arr[1]; + let __v_182: G = __r_arr[2]; + let __v_183: G = __r_arr[3]; + let __v_184: G = __r_arr[4]; + let __v_185: G = __r_arr[5]; + let __v_186: G = G::from_u64(70); + let __v_187: G = G::from_u64(700); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_188: G = __r_arr[0]; + let __v_189: G = __r_arr[1]; + let __v_190: G = __r_arr[2]; + let __v_191: G = __r_arr[3]; + let __v_192: G = __r_arr[4]; + let __v_193: G = __r_arr[5]; + let __v_194: G = G::from_u64(20); + let __v_195: G = G::from_u64(200); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_196: G = __r_arr[0]; + let __v_197: G = __r_arr[1]; + let __v_198: G = __r_arr[2]; + let __v_199: G = __r_arr[3]; + let __v_200: G = __r_arr[4]; + let __v_201: G = __r_arr[5]; + let __v_202: G = G::from_u64(40); + let __v_203: G = G::from_u64(400); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_204: G = __r_arr[0]; + let __v_205: G = __r_arr[1]; + let __v_206: G = __r_arr[2]; + let __v_207: G = __r_arr[3]; + let __v_208: G = __r_arr[4]; + let __v_209: G = __r_arr[5]; + let __v_210: G = G::from_u64(60); + let __v_211: G = G::from_u64(600); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_212: G = __r_arr[0]; + let __v_213: G = __r_arr[1]; + let __v_214: G = __r_arr[2]; + let __v_215: G = __r_arr[3]; + let __v_216: G = __r_arr[4]; + let __v_217: G = __r_arr[5]; + let __v_218: G = G::from_u64(80); + let __v_219: G = G::from_u64(800); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_220: G = __r_arr[0]; + let __v_221: G = __r_arr[1]; + let __v_222: G = __r_arr[2]; + let __v_223: G = __r_arr[3]; + let __v_224: G = __r_arr[4]; + let __v_225: G = __r_arr[5]; + let __v_226: G = G::from_u64(20); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_227: G = __r_arr[0]; + let __v_228: G = G::from_u64(30); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_229: G = __r_arr[0]; + let __v_230: G = G::from_u64(40); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_231: G = __r_arr[0]; + let __v_232: G = G::from_u64(50); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_233: G = __r_arr[0]; + let __v_234: G = G::from_u64(60); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_235: G = __r_arr[0]; + let __v_236: G = G::from_u64(70); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_237: G = __r_arr[0]; + let __v_238: G = G::from_u64(80); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_239: G = __r_arr[0]; + let __ret: [G; OUT_31] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239]; + record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_32: usize = 19; +const IN_32: usize = 19; +const OUT_32: usize = 1; +fn aiur_fn_32( + inp: [G; IN_32], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_32], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(2); + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_30]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(3); + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_30]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __v_37: G = G::from_u64(4); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_40]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_19: G = G::from_u64(5); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_19: G = G::from_u64(6); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = result.output.try_into().unwrap(); __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(7); + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = result.output.try_into().unwrap(); __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_29]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = result.output.try_into().unwrap(); __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(8); + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = result.output.try_into().unwrap(); __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_29]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = result.output.try_into().unwrap(); __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = G::from_u64(9); + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = result.output.try_into().unwrap(); __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_29]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_55: G = __loaded[0]; + let __v_56: G = __loaded[1]; + let __v_57: G = __loaded[2]; + let __v_58: G = __loaded[3]; + let __v_59: G = __loaded[4]; + let __v_60: G = __loaded[5]; + let __v_61: G = __loaded[6]; + let __v_62: G = __loaded[7]; + let __v_63: G = __loaded[8]; + let __v_64: G = __loaded[9]; + let __v_65: G = __loaded[10]; + let __v_66: G = __loaded[11]; + let __v_67: G = __loaded[12]; + let __v_68: G = __loaded[13]; + let __v_69: G = __loaded[14]; + let __v_70: G = __loaded[15]; + let __v_71: G = __loaded[16]; + let __v_72: G = __loaded[17]; + let __v_73: G = G::from_u64(10); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_77]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 11u64 => { + let __v_19: G = G::from_u64(11); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_33: usize = 10; +const IN_33: usize = 10; +const OUT_33: usize = 1; +fn aiur_fn_33( + inp: [G; IN_33], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_33], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_33] = [__v_9]; + record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_8 - __v_12); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_33] = [__v_15]; + record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_34: usize = 9; +const IN_34: usize = 9; +const OUT_34: usize = 1; +fn aiur_fn_34( + inp: [G; IN_34], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_34], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(128); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_11: G = __b2_out[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_34] = [__v_13]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_9 - __v_13); + let __v_15: G = (__v_12 + __v_14); + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_34] = [__v_18]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_9 - __v_13); + let __v_15: G = (__v_12 + __v_14); + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_34] = [__v_18]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_35: usize = 10; +const IN_35: usize = 10; +const OUT_35: usize = 1; +fn aiur_fn_35( + inp: [G; IN_35], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_35], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(32); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_1, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_12: G = __b2_out[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = (__v_14 + __v_1); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_35] = [__v_17]; + record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(32); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + let __v_18: G = (__v_15 + __v_17); + let __v_19: G = (__v_14 + __v_18); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_35] = [__v_22]; + record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(32); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + let __v_18: G = (__v_15 + __v_17); + let __v_19: G = (__v_14 + __v_18); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_35] = [__v_22]; + record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_36: usize = 10; +const IN_36: usize = 10; +const OUT_36: usize = 1; +fn aiur_fn_36( + inp: [G; IN_36], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_36], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(8); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_1, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_12: G = __b2_out[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = (__v_14 + __v_1); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_36] = [__v_17]; + record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(8); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + let __v_18: G = (__v_15 + __v_17); + let __v_19: G = (__v_14 + __v_18); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_36] = [__v_22]; + record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(8); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + let __v_18: G = (__v_15 + __v_17); + let __v_19: G = (__v_14 + __v_18); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_36] = [__v_22]; + record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_37: usize = 2; +const IN_37: usize = 2; +const OUT_37: usize = 1; +fn aiur_fn_37( + inp: [G; IN_37], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_37], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_37] = [__v_1]; + record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_11, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_37] = [__v_13]; + record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_38: usize = 18; +const IN_38: usize = 18; +const OUT_38: usize = 8; +fn aiur_fn_38( + inp: [G; IN_38], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_38], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_0.as_canonical_u64() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = result.output.try_into().unwrap(); __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + let __v_41: G = __r_arr[5]; + let __v_42: G = __r_arr[6]; + let __v_43: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __ret: [G; OUT_38] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_39: usize = 18; +const IN_39: usize = 18; +const OUT_39: usize = 8; +fn aiur_fn_39( + inp: [G; IN_39], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_39], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_0.as_canonical_u64() { + 8u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = result.output.try_into().unwrap(); __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + let __v_41: G = __r_arr[5]; + let __v_42: G = __r_arr[6]; + let __v_43: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __ret: [G; OUT_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_40: usize = 18; +const IN_40: usize = 18; +const OUT_40: usize = 8; +fn aiur_fn_40( + inp: [G; IN_40], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_40], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_0.as_canonical_u64() { + 9u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = result.output.try_into().unwrap(); __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + let __v_41: G = __r_arr[5]; + let __v_42: G = __r_arr[6]; + let __v_43: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_41: usize = 19; +const IN_41: usize = 19; +const OUT_41: usize = 1; +fn aiur_fn_41( + inp: [G; IN_41], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_41], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = result.output.try_into().unwrap(); __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_41] = [__v_56]; + record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_41] = [__v_19]; + record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_42: usize = 19; +const IN_42: usize = 19; +const OUT_42: usize = 1; +fn aiur_fn_42( + inp: [G; IN_42], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_42], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 8u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = result.output.try_into().unwrap(); __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_42] = [__v_56]; + record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_42] = [__v_19]; + record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_43: usize = 19; +const IN_43: usize = 19; +const OUT_43: usize = 1; +fn aiur_fn_43( + inp: [G; IN_43], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_43], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 9u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + let __v_30: G = __loaded[11]; + let __v_31: G = __loaded[12]; + let __v_32: G = __loaded[13]; + let __v_33: G = __loaded[14]; + let __v_34: G = __loaded[15]; + let __v_35: G = __loaded[16]; + let __v_36: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = result.output.try_into().unwrap(); __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_43] = [__v_56]; + record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_43] = [__v_19]; + record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_44: usize = 2; +const IN_44: usize = 2; +const OUT_44: usize = 1; +fn aiur_fn_44( + inp: [G; IN_44], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_44], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = G::from_u64(0); + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = G::from_u64(0); + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = G::from_u64(0); + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = G::from_u64(0); + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = G::from_u64(0); + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_82: G = G::from_u64(0); + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = G::from_u64(0); + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_86: G = G::from_u64(0); + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_88: G = G::from_u64(0); + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_90: G = G::from_u64(0); + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_92: G = G::from_u64(0); + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_94: G = G::from_u64(0); + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_96: G = G::from_u64(0); + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_44] = [__v_97]; + record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_45: usize = 2; +const IN_45: usize = 2; +const OUT_45: usize = 1; +fn aiur_fn_45( + inp: [G; IN_45], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_45], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(2); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(4); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(5); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(6); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(8); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(9); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(10); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_46: usize = 9; +const IN_46: usize = 9; +const OUT_46: usize = 8; +fn aiur_fn_46( + inp: [G; IN_46], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_46], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = result.output.try_into().unwrap(); __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __v_28: G = __r_arr[2]; + let __v_29: G = __r_arr[3]; + let __v_30: G = __r_arr[4]; + let __v_31: G = __r_arr[5]; + let __v_32: G = __r_arr[6]; + let __v_33: G = __r_arr[7]; + let __ret: [G; OUT_46] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_46] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; + record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_47: usize = 9; +const IN_47: usize = 9; +const OUT_47: usize = 9; +fn aiur_fn_47( + inp: [G; IN_47], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_47], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = result.output.try_into().unwrap(); __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __v_26: G = __r_arr[8]; + let __ret: [G; OUT_47] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_48: usize = 10; +const IN_48: usize = 10; +const OUT_48: usize = 1; +fn aiur_fn_48( + inp: [G; IN_48], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_48], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_48] = [__v_12]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = result.output.try_into().unwrap(); __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = result.output.try_into().unwrap(); __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __v_26: G = __r_arr[8]; + let __v_27: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_48] = [__v_29]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_48] = [__v_39]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = G::from_u64(2); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_48] = [__v_39]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_10: G = G::from_u64(3); + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_48] = [__v_11]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_49: usize = 2; +const IN_49: usize = 2; +const OUT_49: usize = 1; +fn aiur_fn_49( + inp: [G; IN_49], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_49], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_49] = [__v_1]; + record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + let __v_10: G = __loaded[5]; + let __v_11: G = __loaded[6]; + let __v_12: G = __loaded[7]; + let __v_13: G = __loaded[8]; + let __v_14: G = __loaded[9]; + let __v_15: G = __loaded[10]; + let __v_16: G = __loaded[11]; + let __v_17: G = __loaded[12]; + let __v_18: G = __loaded[13]; + let __v_19: G = __loaded[14]; + let __v_20: G = __loaded[15]; + let __v_21: G = __loaded[16]; + let __v_22: G = __loaded[17]; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = result.output.try_into().unwrap(); __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_49] = [__v_24]; + record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_50: usize = 2; +const IN_50: usize = 2; +const OUT_50: usize = 1; +fn aiur_fn_50( + inp: [G; IN_50], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_50], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_50] = [__v_1]; + record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + let __v_10: G = __loaded[5]; + let __v_11: G = __loaded[6]; + let __v_12: G = __loaded[7]; + let __v_13: G = __loaded[8]; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = result.output.try_into().unwrap(); __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_50] = [__v_15]; + record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_51: usize = 2; +const IN_51: usize = 2; +const OUT_51: usize = 1; +fn aiur_fn_51( + inp: [G; IN_51], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_51], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_51] = [__v_1]; + record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = result.output.try_into().unwrap(); __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_51] = [__v_6]; + record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_52: usize = 2; +const IN_52: usize = 2; +const OUT_52: usize = 1; +fn aiur_fn_52( + inp: [G; IN_52], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_52], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_52] = [__v_4]; + record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_52] = [__v_4]; + record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_52] = [__v_4]; + record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(3); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_52] = [__v_4]; + record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_53: usize = 13; +const IN_53: usize = 13; +const OUT_53: usize = 1; +fn aiur_fn_53( + inp: [G; IN_53], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_53], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + let __v_34: G = __loaded[3]; + let __v_35: G = __loaded[4]; + let __v_36: G = __loaded[5]; + let __v_37: G = __loaded[6]; + let __v_38: G = __loaded[7]; + let __v_39: G = __loaded[8]; + let __v_40: G = __loaded[9]; + let __v_41: G = __loaded[10]; + let __v_42: G = __loaded[11]; + let __v_43: G = __loaded[12]; + let __v_44: G = __loaded[13]; + let __v_45: G = __loaded[14]; + let __v_46: G = __loaded[15]; + let __v_47: G = __loaded[16]; + let __v_48: G = __loaded[17]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = result.output.try_into().unwrap(); __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_53] = [__v_54]; + record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_54: usize = 10; +const IN_54: usize = 10; +const OUT_54: usize = 1; +fn aiur_fn_54( + inp: [G; IN_54], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_54], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_54] = [__v_29]; + record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_55: usize = 2; +const IN_55: usize = 2; +const OUT_55: usize = 1; +fn aiur_fn_55( + inp: [G; IN_55], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_55], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_55] = [__v_1]; + record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_12, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = result.output.try_into().unwrap(); __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = result.output.try_into().unwrap(); __ret } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_55] = [__v_14]; + record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_56: usize = 45; +const IN_56: usize = 45; +const OUT_56: usize = 1; +fn aiur_fn_56( + inp: [G; IN_56], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_56], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_45: G = __loaded[0]; + let __v_46: G = __loaded[1]; + let __v_47: G = __loaded[2]; + let __v_48: G = __loaded[3]; + let __v_49: G = __loaded[4]; + let __v_50: G = __loaded[5]; + let __v_51: G = __loaded[6]; + let __v_52: G = __loaded[7]; + let __v_53: G = __loaded[8]; + let __v_54: G = __loaded[9]; + let __v_55: G = __loaded[10]; + let __v_56: G = __loaded[11]; + let __v_57: G = __loaded[12]; + let __v_58: G = __loaded[13]; + let __v_59: G = __loaded[14]; + let __v_60: G = __loaded[15]; + let __v_61: G = __loaded[16]; + let __v_62: G = __loaded[17]; + let __v_63: G = G::from_u64(2); + let __v_64: G = (__v_63 * __v_1); + let __v_65: G = (__v_0 + __v_64); + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = result.output.try_into().unwrap(); __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = G::from_u64(0); + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = result.output.try_into().unwrap(); __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_56] = [__v_83]; + record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_57: usize = 11; +const IN_57: usize = 11; +const OUT_57: usize = 1; +fn aiur_fn_57( + inp: [G; IN_57], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_57], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + let __v_27: G = __loaded[16]; + let __v_28: G = __loaded[17]; + let __v_29: G = G::from_u64(0); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_57] = [__v_32]; + record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_58: usize = 11; +const IN_58: usize = 11; +const OUT_58: usize = 1; +fn aiur_fn_58( + inp: [G; IN_58], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_58], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + let __v_27: G = __loaded[16]; + let __v_28: G = __loaded[17]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = result.output.try_into().unwrap(); __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __ret: [G; OUT_58] = [__v_31]; + record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_59: usize = 35; +const IN_59: usize = 35; +const OUT_59: usize = 1; +fn aiur_fn_59( + inp: [G; IN_59], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_59], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + let __v_46: G = __loaded[11]; + let __v_47: G = __loaded[12]; + let __v_48: G = __loaded[13]; + let __v_49: G = __loaded[14]; + let __v_50: G = __loaded[15]; + let __v_51: G = __loaded[16]; + let __v_52: G = __loaded[17]; + let __v_53: G = G::from_u64(0); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_59] = [__v_59]; + record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_60: usize = 2; +const IN_60: usize = 2; +const OUT_60: usize = 1; +fn aiur_fn_60( + inp: [G; IN_60], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_60], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_60] = [__v_1]; + record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_37, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = result.output.try_into().unwrap(); __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = result.output.try_into().unwrap(); __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_60] = [__v_39]; + record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_61: usize = 38; +const IN_61: usize = 38; +const OUT_61: usize = 1; +fn aiur_fn_61( + inp: [G; IN_61], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_61], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __v_49: G = __loaded[11]; + let __v_50: G = __loaded[12]; + let __v_51: G = __loaded[13]; + let __v_52: G = __loaded[14]; + let __v_53: G = __loaded[15]; + let __v_54: G = __loaded[16]; + let __v_55: G = __loaded[17]; + let __v_56: G = G::from_u64(2); + let __v_57: G = (__v_56 * __v_1); + let __v_58: G = G::from_u64(4); + let __v_59: G = (__v_58 * __v_2); + let __v_60: G = (__v_57 + __v_59); + let __v_61: G = (__v_0 + __v_60); + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = result.output.try_into().unwrap(); __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = __r_arr[3]; + let __v_66: G = __r_arr[4]; + let __v_67: G = __r_arr[5]; + let __v_68: G = __r_arr[6]; + let __v_69: G = __r_arr[7]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = result.output.try_into().unwrap(); __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_72]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = { let __values: [G; 3] = [__v_70, __v_61, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_61] = [__v_78]; + record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_62: usize = 10; +const IN_62: usize = 10; +const OUT_62: usize = 1; +fn aiur_fn_62( + inp: [G; IN_62], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_62], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_62] = [__v_11]; + record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_63: usize = 18; +const IN_63: usize = 18; +const OUT_63: usize = 1; +fn aiur_fn_63( + inp: [G; IN_63], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_63], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_63] = [__v_20]; + record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_64: usize = 46; +const IN_64: usize = 46; +const OUT_64: usize = 1; +fn aiur_fn_64( + inp: [G; IN_64], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_64], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = result.output.try_into().unwrap(); __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_64] = [__v_49]; + record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(1); + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = result.output.try_into().unwrap(); __ret } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_64] = [__v_49]; + record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(2); + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = result.output.try_into().unwrap(); __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_64] = [__v_49]; + record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_65: usize = 2; +const IN_65: usize = 2; +const OUT_65: usize = 1; +fn aiur_fn_65( + inp: [G; IN_65], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_65], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_65] = [__v_1]; + record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_48, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = result.output.try_into().unwrap(); __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = result.output.try_into().unwrap(); __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __ret: [G; OUT_65] = [__v_50]; + record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_66: usize = 46; +const IN_66: usize = 46; +const OUT_66: usize = 1; +fn aiur_fn_66( + inp: [G; IN_66], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_66], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = result.output.try_into().unwrap(); __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = result.output.try_into().unwrap(); __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = result.output.try_into().unwrap(); __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = result.output.try_into().unwrap(); __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = result.output.try_into().unwrap(); __ret } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_67: usize = 2; +const IN_67: usize = 2; +const OUT_67: usize = 1; +fn aiur_fn_67( + inp: [G; IN_67], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_67], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = result.output.try_into().unwrap(); __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_67] = [__v_11]; + record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_68: usize = 2; +const IN_68: usize = 2; +const OUT_68: usize = 1; +fn aiur_fn_68( + inp: [G; IN_68], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_68], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = result.output.try_into().unwrap(); __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_68] = [__v_11]; + record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_69: usize = 2; +const IN_69: usize = 2; +const OUT_69: usize = 1; +fn aiur_fn_69( + inp: [G; IN_69], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_69], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = result.output.try_into().unwrap(); __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_69] = [__v_11]; + record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_70: usize = 49; +const IN_70: usize = 49; +const OUT_70: usize = 1; +fn aiur_fn_70( + inp: [G; IN_70], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_70], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = result.output.try_into().unwrap(); __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_46, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = result.output.try_into().unwrap(); __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_45, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = result.output.try_into().unwrap(); __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + match __v_0.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = result.output.try_into().unwrap(); __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = __r_arr[1]; + let __v_54: G = __r_arr[2]; + let __v_55: G = __r_arr[3]; + let __v_56: G = __r_arr[4]; + let __v_57: G = __r_arr[5]; + let __v_58: G = __r_arr[6]; + let __v_59: G = __r_arr[7]; + let __v_60: G = G::from_u64(12); + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = result.output.try_into().unwrap(); __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(1); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(2); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(3); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(4); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(5); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(6); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(7); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_71: usize = 1; +const IN_71: usize = 1; +const OUT_71: usize = 2; +fn aiur_fn_71( + inp: [G; IN_71], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_71], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_71] = [__v_2, __v_3]; + record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_71] = [__v_4, __v_7]; + record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_72: usize = 2; +const IN_72: usize = 2; +const OUT_72: usize = 9; +fn aiur_fn_72( + inp: [G; IN_72], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_72], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_72] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; + record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_1 - __v_4); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = __r_arr[6]; + let __v_13: G = __r_arr[7]; + let __v_14: G = __r_arr[8]; + let __ret: [G; OUT_72] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; + record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_73: usize = 1; +const IN_73: usize = 1; +const OUT_73: usize = 9; +fn aiur_fn_73( + inp: [G; IN_73], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_73], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_4); + let __v_13: G = G::from_u64(4); + let __v_14: G = (__v_13 * __v_5); + let __v_15: G = G::from_u64(8); + let __v_16: G = (__v_15 * __v_6); + let __v_17: G = G::from_u64(16); + let __v_18: G = (__v_17 * __v_7); + let __v_19: G = G::from_u64(32); + let __v_20: G = (__v_19 * __v_8); + let __v_21: G = G::from_u64(64); + let __v_22: G = (__v_21 * __v_9); + let __v_23: G = (__v_20 + __v_22); + let __v_24: G = (__v_18 + __v_23); + let __v_25: G = (__v_16 + __v_24); + let __v_26: G = (__v_14 + __v_25); + let __v_27: G = (__v_12 + __v_26); + let __v_28: G = (__v_3 + __v_27); + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_73] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_2]; + record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_28 + __v_29); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __ret: [G; OUT_73] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; + record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_74: usize = 1; +const IN_74: usize = 1; +const OUT_74: usize = 10; +fn aiur_fn_74( + inp: [G; IN_74], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_74], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_10); + let __v_13: G = (__v_9 + __v_12); + let __v_14: G = G::from_u64(2); + let __v_15: G = (__v_14 * __v_4); + let __v_16: G = G::from_u64(4); + let __v_17: G = (__v_16 * __v_5); + let __v_18: G = G::from_u64(8); + let __v_19: G = (__v_18 * __v_6); + let __v_20: G = G::from_u64(16); + let __v_21: G = (__v_20 * __v_7); + let __v_22: G = (__v_19 + __v_21); + let __v_23: G = (__v_17 + __v_22); + let __v_24: G = (__v_15 + __v_23); + let __v_25: G = (__v_3 + __v_24); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __ret: [G; OUT_74] = [__v_13, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; + record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 + __v_26); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __ret: [G; OUT_74] = [__v_13, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_75: usize = 1; +const IN_75: usize = 1; +const OUT_75: usize = 10; +fn aiur_fn_75( + inp: [G; IN_75], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_75], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_8); + let __v_13: G = G::from_u64(4); + let __v_14: G = (__v_13 * __v_9); + let __v_15: G = G::from_u64(8); + let __v_16: G = (__v_15 * __v_10); + let __v_17: G = (__v_14 + __v_16); + let __v_18: G = (__v_12 + __v_17); + let __v_19: G = (__v_7 + __v_18); + let __v_20: G = G::from_u64(2); + let __v_21: G = (__v_20 * __v_4); + let __v_22: G = G::from_u64(4); + let __v_23: G = (__v_22 * __v_5); + let __v_24: G = (__v_21 + __v_23); + let __v_25: G = (__v_3 + __v_24); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __ret: [G; OUT_75] = [__v_19, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; + record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 + __v_26); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __ret: [G; OUT_75] = [__v_19, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_76: usize = 9; +const IN_76: usize = 9; +const OUT_76: usize = 2; +fn aiur_fn_76( + inp: [G; IN_76], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_76], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_76] = [__v_12, __v_0]; + record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = G::from_u64(0); + let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_76] = [__v_30, __v_28]; + record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_77: usize = 10; +const IN_77: usize = 10; +const OUT_77: usize = 19; +fn aiur_fn_77( + inp: [G; IN_77], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_77], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + let __v_27: G = __loaded[16]; + let __v_28: G = __loaded[17]; + let __ret: [G; OUT_77] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_1]; + record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = G::from_u64(7); + let __v_31: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 18] = [__v_30, __v_0, __v_31, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_33, __v_29, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = result.output.try_into().unwrap(); __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + let __v_45: G = __r_arr[3]; + let __v_46: G = __r_arr[4]; + let __v_47: G = __r_arr[5]; + let __v_48: G = __r_arr[6]; + let __v_49: G = __r_arr[7]; + let __v_50: G = __r_arr[8]; + let __v_51: G = __r_arr[9]; + let __v_52: G = __r_arr[10]; + let __v_53: G = __r_arr[11]; + let __v_54: G = __r_arr[12]; + let __v_55: G = __r_arr[13]; + let __v_56: G = __r_arr[14]; + let __v_57: G = __r_arr[15]; + let __v_58: G = __r_arr[16]; + let __v_59: G = __r_arr[17]; + let __v_60: G = __r_arr[18]; + let __ret: [G; OUT_77] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; + record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_78: usize = 9; +const IN_78: usize = 9; +const OUT_78: usize = 19; +fn aiur_fn_78( + inp: [G; IN_78], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_78], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __ret: [G; OUT_78] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; + record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = result.output.try_into().unwrap(); __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = G::from_u64(8); + let __v_57: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 18] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = G::from_u64(0); + let __ret: [G; OUT_78] = [__v_56, __v_57, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_55]; + record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_79: usize = 9; +const IN_79: usize = 9; +const OUT_79: usize = 19; +fn aiur_fn_79( + inp: [G; IN_79], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_79], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __ret: [G; OUT_79] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; + record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = result.output.try_into().unwrap(); __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = G::from_u64(9); + let __v_57: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 18] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = G::from_u64(0); + let __ret: [G; OUT_79] = [__v_56, __v_57, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_55]; + record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_80: usize = 1; +const IN_80: usize = 1; +const OUT_80: usize = 19; +fn aiur_fn_80( + inp: [G; IN_80], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_80], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_21]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_21]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + let __v_38: G = __r_arr[18]; + let __v_39: G = G::from_u64(4); + let __v_40: G = { let __values: [G; 18] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_80] = [__v_39, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_40, __v_38]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_11: G = G::from_u64(5); + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_11: G = G::from_u64(6); + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30, __v_29, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = result.output.try_into().unwrap(); __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __v_41: G = __r_arr[10]; + let __v_42: G = __r_arr[11]; + let __v_43: G = __r_arr[12]; + let __v_44: G = __r_arr[13]; + let __v_45: G = __r_arr[14]; + let __v_46: G = __r_arr[15]; + let __v_47: G = __r_arr[16]; + let __v_48: G = __r_arr[17]; + let __v_49: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = result.output.try_into().unwrap(); __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = result.output.try_into().unwrap(); __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = result.output.try_into().unwrap(); __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 11u64 => { + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_81: usize = 9; +const IN_81: usize = 9; +const OUT_81: usize = 19; +fn aiur_fn_81( + inp: [G; IN_81], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_81], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = __r_arr[3]; + let __v_13: G = __r_arr[4]; + let __v_14: G = __r_arr[5]; + let __v_15: G = __r_arr[6]; + let __v_16: G = __r_arr[7]; + let __v_17: G = __r_arr[8]; + let __v_18: G = __r_arr[9]; + let __v_19: G = __r_arr[10]; + let __v_20: G = __r_arr[11]; + let __v_21: G = __r_arr[12]; + let __v_22: G = __r_arr[13]; + let __v_23: G = __r_arr[14]; + let __v_24: G = __r_arr[15]; + let __v_25: G = __r_arr[16]; + let __v_26: G = __r_arr[17]; + let __v_27: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __v_38: G = __r_arr[10]; + let __v_39: G = __r_arr[11]; + let __v_40: G = __r_arr[12]; + let __v_41: G = __r_arr[13]; + let __v_42: G = __r_arr[14]; + let __v_43: G = __r_arr[15]; + let __v_44: G = __r_arr[16]; + let __v_45: G = __r_arr[17]; + let __v_46: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __v_57: G = __r_arr[10]; + let __v_58: G = __r_arr[11]; + let __v_59: G = __r_arr[12]; + let __v_60: G = __r_arr[13]; + let __v_61: G = __r_arr[14]; + let __v_62: G = __r_arr[15]; + let __v_63: G = __r_arr[16]; + let __v_64: G = __r_arr[17]; + let __v_65: G = __r_arr[18]; + let __v_66: G = G::from_u64(10); + let __v_67: G = { let __values: [G; 18] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 18] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __ret: [G; OUT_81] = [__v_66, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_67, __v_68, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_65]; + record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_82: usize = 17; +const IN_82: usize = 17; +const OUT_82: usize = 9; +fn aiur_fn_82( + inp: [G; IN_82], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_82], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_82] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = result.output.try_into().unwrap(); __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __v_28: G = __r_arr[2]; + let __v_29: G = __r_arr[3]; + let __v_30: G = __r_arr[4]; + let __v_31: G = __r_arr[5]; + let __v_32: G = __r_arr[6]; + let __v_33: G = __r_arr[7]; + let __v_34: G = __r_arr[8]; + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; + record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_83: usize = 1; +const IN_83: usize = 1; +const OUT_83: usize = 10; +fn aiur_fn_83( + inp: [G; IN_83], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_83], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = result.output.try_into().unwrap(); __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __v_20: G = __r_arr[8]; + let __v_21: G = __r_arr[9]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = result.output.try_into().unwrap(); __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + let __v_24: G = __r_arr[2]; + let __v_25: G = __r_arr[3]; + let __v_26: G = __r_arr[4]; + let __v_27: G = __r_arr[5]; + let __v_28: G = __r_arr[6]; + let __v_29: G = __r_arr[7]; + let __v_30: G = __r_arr[8]; + let __ret: [G; OUT_83] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = G::from_u64(2); + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = G::from_u64(3); + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_11: G = G::from_u64(4); + let __ret: [G; OUT_83] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_84: usize = 1; +const IN_84: usize = 1; +const OUT_84: usize = 2; +fn aiur_fn_84( + inp: [G; IN_84], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_84], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = __r_arr[1]; + let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_84] = [__v_65, __v_64]; + record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_85: usize = 9; +const IN_85: usize = 9; +const OUT_85: usize = 2; +fn aiur_fn_85( + inp: [G; IN_85], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_85], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_12, __v_0]; + record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = result.output.try_into().unwrap(); __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_85] = [__v_41, __v_38]; + record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_86: usize = 9; +const IN_86: usize = 9; +const OUT_86: usize = 2; +fn aiur_fn_86( + inp: [G; IN_86], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_86], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_86] = [__v_12, __v_0]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = result.output.try_into().unwrap(); __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_86] = [__v_32, __v_29]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_87: usize = 9; +const IN_87: usize = 9; +const OUT_87: usize = 2; +fn aiur_fn_87( + inp: [G; IN_87], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_87], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_87] = [__v_12, __v_0]; + record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = result.output.try_into().unwrap(); __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_87] = [__v_23, __v_21]; + record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_88: usize = 1; +const IN_88: usize = 1; +const OUT_88: usize = 2; +fn aiur_fn_88( + inp: [G; IN_88], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_88], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = result.output.try_into().unwrap(); __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_88] = [__v_10, __v_11]; + record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_89: usize = 1; +const IN_89: usize = 1; +const OUT_89: usize = 2; +fn aiur_fn_89( + inp: [G; IN_89], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_89], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = result.output.try_into().unwrap(); __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_89] = [__v_10, __v_11]; + record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_90: usize = 1; +const IN_90: usize = 1; +const OUT_90: usize = 2; +fn aiur_fn_90( + inp: [G; IN_90], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_90], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = result.output.try_into().unwrap(); __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_90] = [__v_10, __v_11]; + record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_91: usize = 1; +const IN_91: usize = 1; +const OUT_91: usize = 2; +fn aiur_fn_91( + inp: [G; IN_91], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_91], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(2); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(2); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_1: G = G::from_u64(2); + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __v_1: G = G::from_u64(2); + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + let __v_1: G = G::from_u64(2); + let __v_2: G = G::from_u64(2); + let __ret: [G; OUT_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_92: usize = 1; +const IN_92: usize = 1; +const OUT_92: usize = 13; +fn aiur_fn_92( + inp: [G; IN_92], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_92], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = result.output.try_into().unwrap(); __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __v_7: G = __r_arr[2]; + let __v_8: G = __r_arr[3]; + let __v_9: G = __r_arr[4]; + let __v_10: G = __r_arr[5]; + let __v_11: G = __r_arr[6]; + let __v_12: G = __r_arr[7]; + let __v_13: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __v_22: G = __r_arr[8]; + let __v_23: G = __r_arr[9]; + let __v_24: G = __r_arr[10]; + let __v_25: G = __r_arr[11]; + let __v_26: G = __r_arr[12]; + let __v_27: G = __r_arr[13]; + let __v_28: G = __r_arr[14]; + let __v_29: G = __r_arr[15]; + let __v_30: G = __r_arr[16]; + let __v_31: G = __r_arr[17]; + let __v_32: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = __r_arr[6]; + let __v_40: G = __r_arr[7]; + let __v_41: G = __r_arr[8]; + let __v_42: G = __r_arr[9]; + let __v_43: G = __r_arr[10]; + let __v_44: G = __r_arr[11]; + let __v_45: G = __r_arr[12]; + let __v_46: G = __r_arr[13]; + let __v_47: G = __r_arr[14]; + let __v_48: G = __r_arr[15]; + let __v_49: G = __r_arr[16]; + let __v_50: G = __r_arr[17]; + let __v_51: G = __r_arr[18]; + let __v_52: G = { let __values: [G; 18] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 18] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_92] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_52, __v_53, __v_51]; + record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_93: usize = 1; +const IN_93: usize = 1; +const OUT_93: usize = 10; +fn aiur_fn_93( + inp: [G; IN_93], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_93], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_93] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29, __v_28]; + record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_94: usize = 9; +const IN_94: usize = 9; +const OUT_94: usize = 2; +fn aiur_fn_94( + inp: [G; IN_94], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_94], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_94] = [__v_12, __v_0]; + record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = result.output.try_into().unwrap(); __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = result.output.try_into().unwrap(); __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_94] = [__v_31, __v_29]; + record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_95: usize = 1; +const IN_95: usize = 1; +const OUT_95: usize = 45; +fn aiur_fn_95( + inp: [G; IN_95], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_95], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __v_37: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = __r_arr[6]; + let __v_63: G = __r_arr[7]; + let __v_64: G = __r_arr[8]; + let __v_65: G = __r_arr[9]; + let __v_66: G = __r_arr[10]; + let __v_67: G = __r_arr[11]; + let __v_68: G = __r_arr[12]; + let __v_69: G = __r_arr[13]; + let __v_70: G = __r_arr[14]; + let __v_71: G = __r_arr[15]; + let __v_72: G = __r_arr[16]; + let __v_73: G = __r_arr[17]; + let __v_74: G = __r_arr[18]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = __r_arr[2]; + let __v_78: G = __r_arr[3]; + let __v_79: G = __r_arr[4]; + let __v_80: G = __r_arr[5]; + let __v_81: G = __r_arr[6]; + let __v_82: G = __r_arr[7]; + let __v_83: G = __r_arr[8]; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_83, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = result.output.try_into().unwrap(); __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = { let __values: [G; 18] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_95] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_86, __v_84, __v_85]; + record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_96: usize = 1; +const IN_96: usize = 1; +const OUT_96: usize = 11; +fn aiur_fn_96( + inp: [G; IN_96], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_96], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __v_20: G = __r_arr[8]; + let __v_21: G = __r_arr[9]; + let __v_22: G = __r_arr[10]; + let __v_23: G = __r_arr[11]; + let __v_24: G = __r_arr[12]; + let __v_25: G = __r_arr[13]; + let __v_26: G = __r_arr[14]; + let __v_27: G = __r_arr[15]; + let __v_28: G = __r_arr[16]; + let __v_29: G = __r_arr[17]; + let __v_30: G = __r_arr[18]; + let __v_31: G = { let __values: [G; 18] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_96] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_31, __v_30]; + record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_97: usize = 1; +const IN_97: usize = 1; +const OUT_97: usize = 1; +fn aiur_fn_97( + inp: [G; IN_97], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_97], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_1: G = G::from_u64(2); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_1: G = G::from_u64(3); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 11; +fn aiur_fn_98( + inp: [G; IN_98], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_98], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = __r_arr[3]; + let __v_17: G = __r_arr[4]; + let __v_18: G = __r_arr[5]; + let __v_19: G = __r_arr[6]; + let __v_20: G = __r_arr[7]; + let __v_21: G = __r_arr[8]; + let __v_22: G = __r_arr[9]; + let __v_23: G = __r_arr[10]; + let __v_24: G = __r_arr[11]; + let __v_25: G = __r_arr[12]; + let __v_26: G = __r_arr[13]; + let __v_27: G = __r_arr[14]; + let __v_28: G = __r_arr[15]; + let __v_29: G = __r_arr[16]; + let __v_30: G = __r_arr[17]; + let __v_31: G = __r_arr[18]; + let __v_32: G = { let __values: [G; 18] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_98] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_32, __v_31]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_99: usize = 1; +const IN_99: usize = 1; +const OUT_99: usize = 35; +fn aiur_fn_99( + inp: [G; IN_99], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_99], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __v_20: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __v_32: G = __r_arr[2]; + let __v_33: G = __r_arr[3]; + let __v_34: G = __r_arr[4]; + let __v_35: G = __r_arr[5]; + let __v_36: G = __r_arr[6]; + let __v_37: G = __r_arr[7]; + let __v_38: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = __r_arr[9]; + let __v_49: G = __r_arr[10]; + let __v_50: G = __r_arr[11]; + let __v_51: G = __r_arr[12]; + let __v_52: G = __r_arr[13]; + let __v_53: G = __r_arr[14]; + let __v_54: G = __r_arr[15]; + let __v_55: G = __r_arr[16]; + let __v_56: G = __r_arr[17]; + let __v_57: G = __r_arr[18]; + let __v_58: G = { let __values: [G; 18] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_99] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_58, __v_57]; + record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_100: usize = 9; +const IN_100: usize = 9; +const OUT_100: usize = 2; +fn aiur_fn_100( + inp: [G; IN_100], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_100], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_100] = [__v_12, __v_0]; + record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = result.output.try_into().unwrap(); __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = __r_arr[4]; + let __v_50: G = __r_arr[5]; + let __v_51: G = __r_arr[6]; + let __v_52: G = __r_arr[7]; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = result.output.try_into().unwrap(); __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_100] = [__v_56, __v_54]; + record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_101: usize = 1; +const IN_101: usize = 1; +const OUT_101: usize = 38; +fn aiur_fn_101( + inp: [G; IN_101], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_101], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __v_37: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __v_57: G = __r_arr[10]; + let __v_58: G = __r_arr[11]; + let __v_59: G = __r_arr[12]; + let __v_60: G = __r_arr[13]; + let __v_61: G = __r_arr[14]; + let __v_62: G = __r_arr[15]; + let __v_63: G = __r_arr[16]; + let __v_64: G = __r_arr[17]; + let __v_65: G = __r_arr[18]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_74, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = result.output.try_into().unwrap(); __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_77, __v_75, __v_76]; + record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_102: usize = 1; +const IN_102: usize = 1; +const OUT_102: usize = 10; +fn aiur_fn_102( + inp: [G; IN_102], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_102], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_102] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_103: usize = 1; +const IN_103: usize = 1; +const OUT_103: usize = 18; +fn aiur_fn_103( + inp: [G; IN_103], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_103], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_103] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; + record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_104: usize = 1; +const IN_104: usize = 1; +const OUT_104: usize = 46; +fn aiur_fn_104( + inp: [G; IN_104], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_104], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = result.output.try_into().unwrap(); __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + let __v_15: G = __r_arr[12]; + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_104] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = result.output.try_into().unwrap(); __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + let __v_15: G = __r_arr[12]; + let __v_16: G = __r_arr[13]; + let __v_17: G = __r_arr[14]; + let __v_18: G = __r_arr[15]; + let __v_19: G = __r_arr[16]; + let __v_20: G = __r_arr[17]; + let __v_21: G = __r_arr[18]; + let __v_22: G = __r_arr[19]; + let __v_23: G = __r_arr[20]; + let __v_24: G = __r_arr[21]; + let __v_25: G = __r_arr[22]; + let __v_26: G = __r_arr[23]; + let __v_27: G = __r_arr[24]; + let __v_28: G = __r_arr[25]; + let __v_29: G = __r_arr[26]; + let __v_30: G = __r_arr[27]; + let __v_31: G = __r_arr[28]; + let __v_32: G = __r_arr[29]; + let __v_33: G = __r_arr[30]; + let __v_34: G = __r_arr[31]; + let __v_35: G = __r_arr[32]; + let __v_36: G = __r_arr[33]; + let __v_37: G = __r_arr[34]; + let __v_38: G = __r_arr[35]; + let __v_39: G = __r_arr[36]; + let __v_40: G = __r_arr[37]; + let __v_41: G = G::from_u64(1); + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_104] = [__v_41, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = result.output.try_into().unwrap(); __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + let __v_15: G = __r_arr[12]; + let __v_16: G = __r_arr[13]; + let __v_17: G = __r_arr[14]; + let __v_18: G = __r_arr[15]; + let __v_19: G = __r_arr[16]; + let __v_20: G = __r_arr[17]; + let __v_21: G = __r_arr[18]; + let __v_22: G = __r_arr[19]; + let __v_23: G = __r_arr[20]; + let __v_24: G = __r_arr[21]; + let __v_25: G = __r_arr[22]; + let __v_26: G = __r_arr[23]; + let __v_27: G = __r_arr[24]; + let __v_28: G = __r_arr[25]; + let __v_29: G = __r_arr[26]; + let __v_30: G = __r_arr[27]; + let __v_31: G = __r_arr[28]; + let __v_32: G = __r_arr[29]; + let __v_33: G = __r_arr[30]; + let __v_34: G = __r_arr[31]; + let __v_35: G = __r_arr[32]; + let __v_36: G = __r_arr[33]; + let __v_37: G = __r_arr[34]; + let __v_38: G = __r_arr[35]; + let __v_39: G = __r_arr[36]; + let __v_40: G = __r_arr[37]; + let __v_41: G = __r_arr[38]; + let __v_42: G = __r_arr[39]; + let __v_43: G = __r_arr[40]; + let __v_44: G = __r_arr[41]; + let __v_45: G = __r_arr[42]; + let __v_46: G = __r_arr[43]; + let __v_47: G = __r_arr[44]; + let __v_48: G = G::from_u64(2); + let __ret: [G; OUT_104] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_105: usize = 9; +const IN_105: usize = 9; +const OUT_105: usize = 2; +fn aiur_fn_105( + inp: [G; IN_105], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_105], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_105] = [__v_12, __v_0]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = result.output.try_into().unwrap(); __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = __r_arr[6]; + let __v_63: G = __r_arr[7]; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = result.output.try_into().unwrap(); __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_105] = [__v_67, __v_65]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_106: usize = 2; +const IN_106: usize = 2; +const OUT_106: usize = 46; +fn aiur_fn_106( + inp: [G; IN_106], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_106], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = result.output.try_into().unwrap(); __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + let __v_14: G = __r_arr[12]; + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = result.output.try_into().unwrap(); __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + let __v_14: G = __r_arr[12]; + let __v_15: G = __r_arr[13]; + let __v_16: G = __r_arr[14]; + let __v_17: G = __r_arr[15]; + let __v_18: G = __r_arr[16]; + let __v_19: G = __r_arr[17]; + let __v_20: G = __r_arr[18]; + let __v_21: G = __r_arr[19]; + let __v_22: G = __r_arr[20]; + let __v_23: G = __r_arr[21]; + let __v_24: G = __r_arr[22]; + let __v_25: G = __r_arr[23]; + let __v_26: G = __r_arr[24]; + let __v_27: G = __r_arr[25]; + let __v_28: G = __r_arr[26]; + let __v_29: G = __r_arr[27]; + let __v_30: G = __r_arr[28]; + let __v_31: G = __r_arr[29]; + let __v_32: G = __r_arr[30]; + let __v_33: G = __r_arr[31]; + let __v_34: G = __r_arr[32]; + let __v_35: G = __r_arr[33]; + let __v_36: G = __r_arr[34]; + let __v_37: G = __r_arr[35]; + let __v_38: G = __r_arr[36]; + let __v_39: G = __r_arr[37]; + let __v_40: G = __r_arr[38]; + let __v_41: G = __r_arr[39]; + let __v_42: G = __r_arr[40]; + let __v_43: G = __r_arr[41]; + let __v_44: G = __r_arr[42]; + let __v_45: G = __r_arr[43]; + let __v_46: G = __r_arr[44]; + let __v_47: G = G::from_u64(1); + let __ret: [G; OUT_106] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = result.output.try_into().unwrap(); __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = G::from_u64(2); + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = result.output.try_into().unwrap(); __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = G::from_u64(3); + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = result.output.try_into().unwrap(); __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + let __v_14: G = __r_arr[12]; + let __v_15: G = __r_arr[13]; + let __v_16: G = __r_arr[14]; + let __v_17: G = __r_arr[15]; + let __v_18: G = __r_arr[16]; + let __v_19: G = __r_arr[17]; + let __v_20: G = G::from_u64(4); + let __v_21: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = G::from_u64(5); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = G::from_u64(6); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = G::from_u64(7); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_107: usize = 10; +const IN_107: usize = 10; +const OUT_107: usize = 46; +fn aiur_fn_107( + inp: [G; IN_107], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_107], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_0.as_canonical_u64() { + 12u64 => { + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = result.output.try_into().unwrap(); __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = G::from_u64(8); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_107] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 13u64 => { + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = result.output.try_into().unwrap(); __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __ret: [G; OUT_107] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_108: usize = 1; +const IN_108: usize = 1; +const OUT_108: usize = 49; +fn aiur_fn_108( + inp: [G; IN_108], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_108], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = result.output.try_into().unwrap(); __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + let __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = __r_arr[19]; + let __v_31: G = __r_arr[20]; + let __v_32: G = __r_arr[21]; + let __v_33: G = __r_arr[22]; + let __v_34: G = __r_arr[23]; + let __v_35: G = __r_arr[24]; + let __v_36: G = __r_arr[25]; + let __v_37: G = __r_arr[26]; + let __v_38: G = __r_arr[27]; + let __v_39: G = __r_arr[28]; + let __v_40: G = __r_arr[29]; + let __v_41: G = __r_arr[30]; + let __v_42: G = __r_arr[31]; + let __v_43: G = __r_arr[32]; + let __v_44: G = __r_arr[33]; + let __v_45: G = __r_arr[34]; + let __v_46: G = __r_arr[35]; + let __v_47: G = __r_arr[36]; + let __v_48: G = __r_arr[37]; + let __v_49: G = __r_arr[38]; + let __v_50: G = __r_arr[39]; + let __v_51: G = __r_arr[40]; + let __v_52: G = __r_arr[41]; + let __v_53: G = __r_arr[42]; + let __v_54: G = __r_arr[43]; + let __v_55: G = __r_arr[44]; + let __v_56: G = __r_arr[45]; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = result.output.try_into().unwrap(); __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = result.output.try_into().unwrap(); __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = result.output.try_into().unwrap(); __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __ret: [G; OUT_108] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_59, __v_61, __v_62]; + record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_109: usize = 1; +const IN_109: usize = 1; +const OUT_109: usize = 3; +fn aiur_fn_109( + inp: [G; IN_109], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_109], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_11, __v_11]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_14, __v_15]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_10: G = G::from_u64(2); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_10, __v_14, __v_18]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_10: G = G::from_u64(3); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_10, __v_14, __v_18]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_10: G = G::from_u64(4); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_11, __v_12]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_110: usize = 2; +const IN_110: usize = 2; +const OUT_110: usize = 1; +fn aiur_fn_110( + inp: [G; IN_110], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_110], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_110] = [__v_14]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = { let __values: [G; 3] = [__v_14, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_110] = [__v_20]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_111: usize = 1; +const IN_111: usize = 1; +const OUT_111: usize = 1; +fn aiur_fn_111( + inp: [G; IN_111], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_111], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = G::from_u64(8); + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = result.output.try_into().unwrap(); __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __v_24: G = G::from_u64(1); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_26]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(1); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 10] = [__v_25, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 10] = [__v_24, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_28]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = result.output.try_into().unwrap(); __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 10] = [__v_24, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_25]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_112: usize = 10; +const IN_112: usize = 10; +const OUT_112: usize = 8; +fn aiur_fn_112( + inp: [G; IN_112], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_112], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_9.as_canonical_u64() { + 8u64 => { + let __ret: [G; OUT_112] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_112] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_13: G = G::from_u64(2); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_13: G = G::from_u64(3); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_13: G = G::from_u64(4); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_13: G = G::from_u64(5); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_13: G = G::from_u64(6); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_13: G = G::from_u64(7); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(8); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_113: usize = 2; +const IN_113: usize = 2; +const OUT_113: usize = 1; +fn aiur_fn_113( + inp: [G; IN_113], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_113], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_113] = [__v_0]; + record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_113] = [__v_7]; + record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = result.output.try_into().unwrap(); __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_113] = [__v_7]; + record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_114: usize = 6; +const IN_114: usize = 6; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_114], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __v_17: G = __loaded[11]; + let __v_18: G = __loaded[12]; + let __v_19: G = __loaded[13]; + let __v_20: G = __loaded[14]; + let __v_21: G = __loaded[15]; + let __v_22: G = __loaded[16]; + let __v_23: G = __loaded[17]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = { let __values: [G; 3] = [__v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 4] = [__v_26, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_32]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_24: G = G::from_u64(0); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_27]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(8); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_25, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(7); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_24, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = result.output.try_into().unwrap(); __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(7); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_24: G = G::from_u64(3); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_24: G = G::from_u64(4); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __v_24: G = G::from_u64(5); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + let __v_24: G = G::from_u64(6); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 11u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + match __v_26.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_115: usize = 7; +const IN_115: usize = 7; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_115], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 5] = [__v_18, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_115] = [__v_20]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + match __v_18.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = result.output.try_into().unwrap(); __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = { let __values: [G; 5] = [__v_23, __v_19, __v_22, __v_21, __v_24]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_115] = [__v_25]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_116: usize = 18; +const IN_116: usize = 18; +const OUT_116: usize = 11; +fn aiur_fn_116( + inp: [G; IN_116], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_116], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_12.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_1, __v_17, __v_22, __v_22, __v_22, __v_22, __v_22]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(3); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(3); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_20: G = G::from_u64(2); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_117: usize = 15; +const IN_117: usize = 15; +const OUT_117: usize = 11; +fn aiur_fn_117( + inp: [G; IN_117], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_117], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + match __v_10.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_117] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; + record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_118: usize = 15; +const IN_118: usize = 15; +const OUT_118: usize = 11; +fn aiur_fn_118( + inp: [G; IN_118], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_118], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + match __v_10.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(4); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_118] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; + record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_119: usize = 51; +const IN_119: usize = 51; +const OUT_119: usize = 11; +fn aiur_fn_119( + inp: [G; IN_119], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_119], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + match __v_44.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = result.output.try_into().unwrap(); __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = G::from_u64(7); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __ret: [G; OUT_119] = [__v_53, __v_54, __v_51, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_50]; + record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_120: usize = 44; +const IN_120: usize = 44; +const OUT_120: usize = 11; +fn aiur_fn_120( + inp: [G; IN_120], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_120], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + match __v_37.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_35, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = G::from_u64(5); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_120] = [__v_45, __v_46, __v_44, __v_47, __v_48, __v_42, __v_0, __v_1, __v_2, __v_49, __v_43]; + record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_121: usize = 40; +const IN_121: usize = 40; +const OUT_121: usize = 11; +fn aiur_fn_121( + inp: [G; IN_121], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_121], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + match __v_34.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(6); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __ret: [G; OUT_121] = [__v_41, __v_42, __v_40, __v_39, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_122: usize = 1; +const IN_122: usize = 1; +const OUT_122: usize = 11; +fn aiur_fn_122( + inp: [G; IN_122], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_122], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 52] = { let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 52 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 52] = __args[..52].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + let __v_49: G = __loaded[48]; + let __v_50: G = __loaded[49]; + let __v_51: G = __loaded[50]; + let __v_52: G = __loaded[51]; + match __v_1.as_canonical_u64() { + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = result.output.try_into().unwrap(); __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = result.output.try_into().unwrap(); __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = result.output.try_into().unwrap(); __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_1, __v_2, __v_3, __v_4, __v_5, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = result.output.try_into().unwrap(); __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_1, __v_2, __v_3, __v_4, __v_5, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = result.output.try_into().unwrap(); __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = result.output.try_into().unwrap(); __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_123: usize = 1; +const IN_123: usize = 1; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: [G; IN_123], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_123], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_123] = [__v_6]; + record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = result.output.try_into().unwrap(); __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __v_13: G = __r_arr[9]; + let __v_14: G = __r_arr[10]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 11] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_123] = [__v_18]; + record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 48; +fn aiur_fn_124( + inp: [G; IN_124], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_124], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(2); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __v_47: G = __r_arr[9]; + let __v_48: G = __r_arr[10]; + let __v_49: G = __r_arr[11]; + let __v_50: G = __r_arr[12]; + let __v_51: G = __r_arr[13]; + let __v_52: G = __r_arr[14]; + let __v_53: G = __r_arr[15]; + let __v_54: G = __r_arr[16]; + let __v_55: G = __r_arr[17]; + let __v_56: G = __r_arr[18]; + let __v_57: G = __r_arr[19]; + let __v_58: G = __r_arr[20]; + let __v_59: G = __r_arr[21]; + let __v_60: G = __r_arr[22]; + let __v_61: G = __r_arr[23]; + let __v_62: G = __r_arr[24]; + let __v_63: G = __r_arr[25]; + let __v_64: G = __r_arr[26]; + let __v_65: G = __r_arr[27]; + let __v_66: G = __r_arr[28]; + let __v_67: G = __r_arr[29]; + let __v_68: G = __r_arr[30]; + let __v_69: G = __r_arr[31]; + let __v_70: G = __r_arr[32]; + let __v_71: G = __r_arr[33]; + let __v_72: G = __r_arr[34]; + let __v_73: G = __r_arr[35]; + let __v_74: G = __r_arr[36]; + let __v_75: G = __r_arr[37]; + let __v_76: G = __r_arr[38]; + let __v_77: G = __r_arr[39]; + let __v_78: G = __r_arr[40]; + let __v_79: G = __r_arr[41]; + let __v_80: G = __r_arr[42]; + let __v_81: G = __r_arr[43]; + let __v_82: G = __r_arr[44]; + let __v_83: G = __r_arr[45]; + let __v_84: G = __r_arr[46]; + let __v_85: G = __r_arr[47]; + let __v_86: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_87: G = __loaded[0]; + let __v_88: G = __loaded[1]; + let __v_89: G = __loaded[2]; + let __v_90: G = G::from_u64(1); + let __v_91: G = G::from_u64(1); + if (__v_87 != __v_90) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_90.as_canonical_u64() }); + } + if (__v_88 != __v_91) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_91.as_canonical_u64() }); + } + if (__v_89 != __v_91) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64() }); + } + let __ret: [G; OUT_124] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_125: usize = 1; +const IN_125: usize = 1; +const OUT_125: usize = 1; +fn aiur_fn_125( + inp: [G; IN_125], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_125], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(5); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(5); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_125] = [__v_37]; + record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_126: usize = 2; +const IN_126: usize = 2; +const OUT_126: usize = 1; +fn aiur_fn_126( + inp: [G; IN_126], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_126], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = (__v_3 - __v_35); + let __v_67: G = (__v_4 - __v_36); + let __v_68: G = (__v_5 - __v_37); + let __v_69: G = (__v_6 - __v_38); + let __v_70: G = (__v_7 - __v_39); + let __v_71: G = (__v_8 - __v_40); + let __v_72: G = (__v_9 - __v_41); + let __v_73: G = (__v_10 - __v_42); + let __v_74: G = (__v_11 - __v_43); + let __v_75: G = (__v_12 - __v_44); + let __v_76: G = (__v_13 - __v_45); + let __v_77: G = (__v_14 - __v_46); + let __v_78: G = (__v_15 - __v_47); + let __v_79: G = (__v_16 - __v_48); + let __v_80: G = (__v_17 - __v_49); + let __v_81: G = (__v_18 - __v_50); + let __v_82: G = (__v_19 - __v_51); + let __v_83: G = (__v_20 - __v_52); + let __v_84: G = (__v_21 - __v_53); + let __v_85: G = (__v_22 - __v_54); + let __v_86: G = (__v_23 - __v_55); + let __v_87: G = (__v_24 - __v_56); + let __v_88: G = (__v_25 - __v_57); + let __v_89: G = (__v_26 - __v_58); + let __v_90: G = (__v_27 - __v_59); + let __v_91: G = (__v_28 - __v_60); + let __v_92: G = (__v_29 - __v_61); + let __v_93: G = (__v_30 - __v_62); + let __v_94: G = (__v_31 - __v_63); + let __v_95: G = (__v_32 - __v_64); + let __v_96: G = (__v_33 - __v_65); + match __v_66.as_canonical_u64() { + 0u64 => { + match __v_67.as_canonical_u64() { + 0u64 => { + match __v_68.as_canonical_u64() { + 0u64 => { + match __v_69.as_canonical_u64() { + 0u64 => { + match __v_70.as_canonical_u64() { + 0u64 => { + match __v_71.as_canonical_u64() { + 0u64 => { + match __v_72.as_canonical_u64() { + 0u64 => { + match __v_73.as_canonical_u64() { + 0u64 => { + match __v_74.as_canonical_u64() { + 0u64 => { + match __v_75.as_canonical_u64() { + 0u64 => { + match __v_76.as_canonical_u64() { + 0u64 => { + match __v_77.as_canonical_u64() { + 0u64 => { + match __v_78.as_canonical_u64() { + 0u64 => { + match __v_79.as_canonical_u64() { + 0u64 => { + match __v_80.as_canonical_u64() { + 0u64 => { + match __v_81.as_canonical_u64() { + 0u64 => { + match __v_82.as_canonical_u64() { + 0u64 => { + match __v_83.as_canonical_u64() { + 0u64 => { + match __v_84.as_canonical_u64() { + 0u64 => { + match __v_85.as_canonical_u64() { + 0u64 => { + match __v_86.as_canonical_u64() { + 0u64 => { + match __v_87.as_canonical_u64() { + 0u64 => { + match __v_88.as_canonical_u64() { + 0u64 => { + match __v_89.as_canonical_u64() { + 0u64 => { + match __v_90.as_canonical_u64() { + 0u64 => { + match __v_91.as_canonical_u64() { + 0u64 => { + match __v_92.as_canonical_u64() { + 0u64 => { + match __v_93.as_canonical_u64() { + 0u64 => { + match __v_94.as_canonical_u64() { + 0u64 => { + match __v_95.as_canonical_u64() { + 0u64 => { + match __v_96.as_canonical_u64() { + 0u64 => { + let __v_97: G = G::from_u64(1); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_127: usize = 2; +const IN_127: usize = 2; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: [G; IN_127], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_127], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = (__v_2 - __v_34); + match __v_66.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = result.output.try_into().unwrap(); __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __ret: [G; OUT_127] = [__v_67]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_67: G = G::from_u64(0); + let __ret: [G; OUT_127] = [__v_67]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_128: usize = 1; +const IN_128: usize = 1; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_128], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(3); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(3); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + match __v_38.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_128] = [__v_39]; + record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_129: usize = 0; +const IN_129: usize = 0; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_129], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(4294967295); + let __ret: [G; OUT_129] = [__v_0]; + record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_130: usize = 45; +const IN_130: usize = 45; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_130], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + 6u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_17]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_131: usize = 45; +const IN_131: usize = 45; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_131], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(1); + let __v_47: G = (__v_45 + __v_46); + let __ret: [G; OUT_131] = [__v_47]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_45: G = G::from_u64(1); + let __ret: [G; OUT_131] = [__v_45]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_45: G = G::from_u64(1); + let __ret: [G; OUT_131] = [__v_45]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_132: usize = 1; +const IN_132: usize = 1; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_132], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_132] = [__v_48]; + record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = (__v_48 + __v_49); + let __ret: [G; OUT_132] = [__v_50]; + record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_133: usize = 2; +const IN_133: usize = 2; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_133], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_133] = [__v_2]; + record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_1 - __v_50); + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_48, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = (__v_49 + __v_52); + let __ret: [G; OUT_133] = [__v_53]; + record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_134: usize = 4; +const IN_134: usize = 4; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_134], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_134] = [__v_12]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4294967295u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_134] = [__v_12]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_11 - __v_12); + let __ret: [G; OUT_134] = [__v_13]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_135: usize = 3; +const IN_135: usize = 3; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_135], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_135] = [__v_6]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_135] = [__v_7]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_135] = [__v_10]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_136: usize = 2; +const IN_136: usize = 2; +const OUT_136: usize = 6; +fn aiur_fn_136( + inp: [G; IN_136], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_136], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_136] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; + record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_6 + __v_8); + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = result.output.try_into().unwrap(); __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_137: usize = 7; +const IN_137: usize = 7; +const OUT_137: usize = 6; +fn aiur_fn_137( + inp: [G; IN_137], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_137], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __v_28: G = __loaded[18]; + let __v_29: G = __loaded[19]; + let __v_30: G = __loaded[20]; + let __v_31: G = __loaded[21]; + let __v_32: G = __loaded[22]; + let __v_33: G = __loaded[23]; + let __v_34: G = __loaded[24]; + let __v_35: G = __loaded[25]; + let __v_36: G = __loaded[26]; + let __v_37: G = __loaded[27]; + let __v_38: G = __loaded[28]; + let __v_39: G = __loaded[29]; + let __v_40: G = __loaded[30]; + let __v_41: G = __loaded[31]; + let __v_42: G = __loaded[32]; + let __v_43: G = __loaded[33]; + let __v_44: G = __loaded[34]; + let __v_45: G = __loaded[35]; + let __v_46: G = __loaded[36]; + let __v_47: G = __loaded[37]; + let __v_48: G = __loaded[38]; + let __v_49: G = __loaded[39]; + let __v_50: G = __loaded[40]; + let __v_51: G = __loaded[41]; + let __v_52: G = __loaded[42]; + let __v_53: G = __loaded[43]; + let __v_54: G = __loaded[44]; + let __v_55: G = __loaded[45]; + let __v_56: G = __loaded[46]; + let __v_57: G = __loaded[47]; + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = result.output.try_into().unwrap(); __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __ret: [G; OUT_137] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_138: usize = 7; +const IN_138: usize = 7; +const OUT_138: usize = 6; +fn aiur_fn_138( + inp: [G; IN_138], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_138], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_138] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = result.output.try_into().unwrap(); __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = __r_arr[3]; + let __v_17: G = __r_arr[4]; + let __v_18: G = __r_arr[5]; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __ret: [G; OUT_138] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __ret: [G; OUT_138] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_139: usize = 2; +const IN_139: usize = 2; +const OUT_139: usize = 6; +fn aiur_fn_139( + inp: [G; IN_139], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_139], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = result.output.try_into().unwrap(); __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __ret: [G; OUT_139] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_140: usize = 8; +const IN_140: usize = 8; +const OUT_140: usize = 6; +fn aiur_fn_140( + inp: [G; IN_140], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_140], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_140] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = result.output.try_into().unwrap(); __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __ret: [G; OUT_140] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_141: usize = 2; +const IN_141: usize = 2; +const OUT_141: usize = 1; +fn aiur_fn_141( + inp: [G; IN_141], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_141], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_141] = [__v_9]; + record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_142: usize = 2; +const IN_142: usize = 2; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_142], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_142] = [__v_5]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = (__v_3 - __v_0); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_142] = [__v_6]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_142] = [__v_6]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_143: usize = 48; +const IN_143: usize = 48; +const OUT_143: usize = 1; +fn aiur_fn_143( + inp: [G; IN_143], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_143], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + match __v_0.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = result.output.try_into().unwrap(); __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + match __v_48.as_canonical_u64() { + 0u64 => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_143] = [__v_49]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_49: G = { let __values: [G; 48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_143] = [__v_49]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64())); + }, + } + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_143] = [__v_48]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_144: usize = 1; +const IN_144: usize = 1; +const OUT_144: usize = 1; +fn aiur_fn_144( + inp: [G; IN_144], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_144], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_47.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_48: G = __loaded[0]; + let __v_49: G = __loaded[1]; + let __v_50: G = __loaded[2]; + let __v_51: G = __loaded[3]; + let __v_52: G = __loaded[4]; + let __v_53: G = __loaded[5]; + let __v_54: G = __loaded[6]; + let __v_55: G = __loaded[7]; + let __v_56: G = __loaded[8]; + let __v_57: G = __loaded[9]; + let __v_58: G = __loaded[10]; + let __v_59: G = __loaded[11]; + let __v_60: G = __loaded[12]; + let __v_61: G = __loaded[13]; + let __v_62: G = __loaded[14]; + let __v_63: G = __loaded[15]; + let __v_64: G = __loaded[16]; + let __v_65: G = __loaded[17]; + let __v_66: G = __loaded[18]; + let __v_67: G = __loaded[19]; + let __v_68: G = __loaded[20]; + let __v_69: G = __loaded[21]; + let __v_70: G = __loaded[22]; + let __v_71: G = __loaded[23]; + let __v_72: G = __loaded[24]; + let __v_73: G = __loaded[25]; + let __v_74: G = __loaded[26]; + let __v_75: G = __loaded[27]; + let __v_76: G = __loaded[28]; + let __v_77: G = __loaded[29]; + let __v_78: G = __loaded[30]; + let __v_79: G = __loaded[31]; + let __v_80: G = __loaded[32]; + let __v_81: G = __loaded[33]; + let __v_82: G = __loaded[34]; + let __v_83: G = __loaded[35]; + let __v_84: G = __loaded[36]; + let __v_85: G = __loaded[37]; + let __v_86: G = __loaded[38]; + let __v_87: G = __loaded[39]; + let __v_88: G = __loaded[40]; + let __v_89: G = __loaded[41]; + let __v_90: G = __loaded[42]; + let __v_91: G = __loaded[43]; + let __v_92: G = __loaded[44]; + let __v_93: G = __loaded[45]; + let __v_94: G = __loaded[46]; + match __v_48.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_95: G = G::from_u64(1); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_95: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_95: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_48]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_145: usize = 3; +const IN_145: usize = 3; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_145], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_145] = [__v_6]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_9: G = (__v_4 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_145] = [__v_7]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_145] = [__v_10]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_146: usize = 3; +const IN_146: usize = 3; +const OUT_146: usize = 3; +fn aiur_fn_146( + inp: [G; IN_146], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_146], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __ret: [G; OUT_146] = [__v_9, __v_10, __v_11]; + record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_147: usize = 5; +const IN_147: usize = 5; +const OUT_147: usize = 3; +fn aiur_fn_147( + inp: [G; IN_147], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_147], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_10, __v_13, __v_2]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __v_19: G = __loaded[11]; + let __v_20: G = __loaded[12]; + let __v_21: G = __loaded[13]; + let __v_22: G = __loaded[14]; + let __v_23: G = __loaded[15]; + let __v_24: G = __loaded[16]; + let __v_25: G = __loaded[17]; + let __v_26: G = __loaded[18]; + let __v_27: G = __loaded[19]; + let __v_28: G = __loaded[20]; + let __v_29: G = __loaded[21]; + let __v_30: G = __loaded[22]; + let __v_31: G = __loaded[23]; + let __v_32: G = __loaded[24]; + let __v_33: G = __loaded[25]; + let __v_34: G = __loaded[26]; + let __v_35: G = __loaded[27]; + let __v_36: G = __loaded[28]; + let __v_37: G = __loaded[29]; + let __v_38: G = __loaded[30]; + let __v_39: G = __loaded[31]; + let __v_40: G = __loaded[32]; + let __v_41: G = __loaded[33]; + let __v_42: G = __loaded[34]; + let __v_43: G = __loaded[35]; + let __v_44: G = __loaded[36]; + let __v_45: G = __loaded[37]; + let __v_46: G = __loaded[38]; + let __v_47: G = __loaded[39]; + let __v_48: G = __loaded[40]; + let __v_49: G = __loaded[41]; + let __v_50: G = __loaded[42]; + let __v_51: G = __loaded[43]; + let __v_52: G = __loaded[44]; + let __v_53: G = __loaded[45]; + let __v_54: G = __loaded[46]; + let __v_55: G = __loaded[47]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_56: G = __loaded[0]; + let __v_57: G = __loaded[1]; + let __v_58: G = __loaded[2]; + match __v_56.as_canonical_u64() { + 0u64 => { + match __v_8.as_canonical_u64() { + _ => { + match __v_8.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() { + 0u64 => { + let __v_60: G = G::from_u64(0); + break '__mc_0 [__v_60]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_59, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + break '__mc_0 [__v_60]; + }, +} + }; + let __v_60: G = __mc_out___mc_0[0]; + match __v_60.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_59, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 3] = [__v_65, __v_57, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 3] = [__v_67, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_66, __v_68, __v_64]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_3]; + }, + _ => { + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_59, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_1 [__v_63]; + }, +} + }; + let __v_62: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_59.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_4]; + }, + _ => { + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 3] = [__v_63, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_64]; + }, +} + }; + let __v_63: G = __mc_out___mc_2[0]; + let __v_64: G = (__v_2 + __v_61); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = __r_arr[1]; + let __v_67: G = __r_arr[2]; + let __v_68: G = G::from_u64(0); + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_57, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_2, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_69, __v_71, __v_67]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_148: usize = 4; +const IN_148: usize = 4; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_148], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_148] = [__v_10]; + record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_149: usize = 6; +const IN_149: usize = 6; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_149], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_11]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + let __v_45: G = __loaded[36]; + let __v_46: G = __loaded[37]; + let __v_47: G = __loaded[38]; + let __v_48: G = __loaded[39]; + let __v_49: G = __loaded[40]; + let __v_50: G = __loaded[41]; + let __v_51: G = __loaded[42]; + let __v_52: G = __loaded[43]; + let __v_53: G = __loaded[44]; + let __v_54: G = __loaded[45]; + let __v_55: G = __loaded[46]; + let __v_56: G = __loaded[47]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + match __v_57.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + _ => { + match __v_9.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() { + 0u64 => { + let __v_61: G = G::from_u64(0); + break '__mc_0 [__v_61]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_60, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + break '__mc_0 [__v_61]; + }, +} + }; + let __v_61: G = __mc_out___mc_0[0]; + match __v_61.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_60, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = { let __values: [G; 3] = [__v_63, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_65]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_4]; + }, + _ => { + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 3] = [__v_63, __v_60, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_1 [__v_64]; + }, +} + }; + let __v_63: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_60.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_5]; + }, + _ => { + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_3, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_65]; + }, +} + }; + let __v_64: G = __mc_out___mc_2[0]; + let __v_65: G = G::from_u64(0); + let __v_66: G = (__v_3 + __v_62); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = { let __values: [G; 3] = [__v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_68]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 4u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_26, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = G::from_u64(1); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = (__v_112 + __v_113); + let __v_115: G = (__v_110 + __v_114); + let __v_116: G = (__v_60 + __v_115); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __v_118: G = { let __values: [G; 3] = [__v_111, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_118]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 5u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 7u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(1); + let __v_62: G = (__v_3 + __v_61); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = { let __values: [G; 3] = [__v_60, __v_3, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_64]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_150: usize = 4; +const IN_150: usize = 4; +const OUT_150: usize = 2; +fn aiur_fn_150( + inp: [G; IN_150], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_150], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_9, __v_12]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_17, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(1); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_20, __v_23, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_19, __v_24]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4294967295u64 => { + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = result.output.try_into().unwrap(); __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_17, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_20, __v_22]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_16 - __v_18); + let __v_20: G = { let __values: [G; 3] = [__v_17, __v_19, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_21, __v_24, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_20, __v_25]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_151: usize = 1; +const IN_151: usize = 1; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_151], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + match __v_1.as_canonical_u64() { + _ => { + match __v_1.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = result.output.try_into().unwrap(); __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + match __v_49.as_canonical_u64() { + 0u64 => { + let __v_50: G = G::from_u64(0); + let __ret: [G; OUT_151] = [__v_50]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_151] = [__v_0]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, + } + }, + _ => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_151] = [__v_49]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_152: usize = 4; +const IN_152: usize = 4; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_152], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_152] = [__v_3]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_10: G = (__v_5 - __v_0); + match __v_10.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_152] = [__v_8]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_152] = [__v_11]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_153: usize = 4; +const IN_153: usize = 4; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_153], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_9]; + record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = result.output.try_into().unwrap(); __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_2]; + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_10, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_1 [__v_13]; + }, +} + }; + let __v_12: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_3]; + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_11, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_14]; + }, +} + }; + let __v_13: G = __mc_out___mc_2[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = result.output.try_into().unwrap(); __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_11, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_16]; + record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_154: usize = 2; +const IN_154: usize = 2; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_154], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = result.output.try_into().unwrap(); __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_154] = [__v_8]; + record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_155: usize = 10; +const IN_155: usize = 10; +const OUT_155: usize = 6; +fn aiur_fn_155( + inp: [G; IN_155], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_155], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_155] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = result.output.try_into().unwrap(); __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __ret: [G; OUT_155] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + let __v_24: G = __r_arr[2]; + let __v_25: G = __r_arr[3]; + let __v_26: G = __r_arr[4]; + let __v_27: G = __r_arr[5]; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __ret: [G; OUT_155] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_156: usize = 2; +const IN_156: usize = 2; +const OUT_156: usize = 6; +fn aiur_fn_156( + inp: [G; IN_156], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_156], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_4, __v_7, __v_8, __v_9, __v_9, __v_9, __v_9, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __ret: [G; OUT_156] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_157: usize = 2; +const IN_157: usize = 2; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_157], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_157] = [__v_0]; + record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_157] = [__v_14]; + record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_158: usize = 3; +const IN_158: usize = 3; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_158], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = result.output.try_into().unwrap(); __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_158] = [__v_3]; + record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_159: usize = 2; +const IN_159: usize = 2; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_159], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_159] = [__v_51]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = (__v_1 + __v_50); + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_48, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = result.output.try_into().unwrap(); __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_1, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_159] = [__v_53]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_160: usize = 3; +const IN_160: usize = 3; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: [G; IN_160], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_160], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_160] = [__v_5]; + record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_4 + __v_2); + let __v_6: G = (__v_1 + __v_5); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_0 - __v_7); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_8, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 3] = [__v_3, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_160] = [__v_12]; + record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_161: usize = 3; +const IN_161: usize = 3; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_161], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_161] = [__v_3]; + record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_162: usize = 2; +const IN_162: usize = 2; +const OUT_162: usize = 1; +fn aiur_fn_162( + inp: [G; IN_162], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_162], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_3.as_canonical_u64() { + 1u64 => { + match __v_4.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_49, __v_1, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = G::from_u64(1); + let __v_53: G = (__v_52 + __v_49); + let __v_54: G = (__v_1 + __v_53); + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_56]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_1 + __v_49); + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_1 + __v_49); + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_163: usize = 1; +const IN_163: usize = 1; +const OUT_163: usize = 1; +fn aiur_fn_163( + inp: [G; IN_163], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_163], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(1); + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = result.output.try_into().unwrap(); __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_164: usize = 19; +const IN_164: usize = 19; +const OUT_164: usize = 18; +fn aiur_fn_164( + inp: [G; IN_164], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_164], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 11u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + match __v_21.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + let __v_35: G = __loaded[11]; + let __v_36: G = __loaded[12]; + let __v_37: G = __loaded[13]; + let __v_38: G = __loaded[14]; + let __v_39: G = __loaded[15]; + let __v_40: G = __loaded[16]; + let __v_41: G = __loaded[17]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + let __v_45: G = __r_arr[3]; + let __v_46: G = __r_arr[4]; + let __v_47: G = __r_arr[5]; + let __v_48: G = __r_arr[6]; + let __v_49: G = __r_arr[7]; + let __v_50: G = __r_arr[8]; + let __v_51: G = __r_arr[9]; + let __v_52: G = __r_arr[10]; + let __v_53: G = __r_arr[11]; + let __v_54: G = __r_arr[12]; + let __v_55: G = __r_arr[13]; + let __v_56: G = __r_arr[14]; + let __v_57: G = __r_arr[15]; + let __v_58: G = __r_arr[16]; + let __v_59: G = __r_arr[17]; + let __ret: [G; OUT_164] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_165: usize = 20; +const IN_165: usize = 20; +const OUT_165: usize = 18; +fn aiur_fn_165( + inp: [G; IN_165], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_165], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + let __ret: [G; OUT_165] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + match __v_20.as_canonical_u64() { + 9u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __v_49: G = __loaded[11]; + let __v_50: G = __loaded[12]; + let __v_51: G = __loaded[13]; + let __v_52: G = __loaded[14]; + let __v_53: G = __loaded[15]; + let __v_54: G = __loaded[16]; + let __v_55: G = __loaded[17]; + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_18 - __v_56); + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = result.output.try_into().unwrap(); __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __v_64: G = __r_arr[6]; + let __v_65: G = __r_arr[7]; + let __v_66: G = __r_arr[8]; + let __v_67: G = __r_arr[9]; + let __v_68: G = __r_arr[10]; + let __v_69: G = __r_arr[11]; + let __v_70: G = __r_arr[12]; + let __v_71: G = __r_arr[13]; + let __v_72: G = __r_arr[14]; + let __v_73: G = __r_arr[15]; + let __v_74: G = __r_arr[16]; + let __v_75: G = __r_arr[17]; + let __ret: [G; OUT_165] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_166: usize = 19; +const IN_166: usize = 19; +const OUT_166: usize = 18; +fn aiur_fn_166( + inp: [G; IN_166], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_166], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = __r_arr[8]; + let __v_28: G = __r_arr[9]; + let __v_29: G = __r_arr[10]; + let __v_30: G = __r_arr[11]; + let __v_31: G = __r_arr[12]; + let __v_32: G = __r_arr[13]; + let __v_33: G = __r_arr[14]; + let __v_34: G = __r_arr[15]; + let __v_35: G = __r_arr[16]; + let __v_36: G = __r_arr[17]; + match __v_19.as_canonical_u64() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + let __v_40: G = __loaded[3]; + let __v_41: G = __loaded[4]; + let __v_42: G = __loaded[5]; + let __v_43: G = __loaded[6]; + let __v_44: G = __loaded[7]; + let __v_45: G = __loaded[8]; + let __v_46: G = __loaded[9]; + let __v_47: G = __loaded[10]; + let __v_48: G = __loaded[11]; + let __v_49: G = __loaded[12]; + let __v_50: G = __loaded[13]; + let __v_51: G = __loaded[14]; + let __v_52: G = __loaded[15]; + let __v_53: G = __loaded[16]; + let __v_54: G = __loaded[17]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = result.output.try_into().unwrap(); __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = __r_arr[2]; + let __v_58: G = __r_arr[3]; + let __v_59: G = __r_arr[4]; + let __v_60: G = __r_arr[5]; + let __v_61: G = __r_arr[6]; + let __v_62: G = __r_arr[7]; + let __v_63: G = __r_arr[8]; + let __v_64: G = __r_arr[9]; + let __v_65: G = __r_arr[10]; + let __v_66: G = __r_arr[11]; + let __v_67: G = __r_arr[12]; + let __v_68: G = __r_arr[13]; + let __v_69: G = __r_arr[14]; + let __v_70: G = __r_arr[15]; + let __v_71: G = __r_arr[16]; + let __v_72: G = __r_arr[17]; + let __ret: [G; OUT_166] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; + record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __ret: [G; OUT_166] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_167: usize = 21; +const IN_167: usize = 21; +const OUT_167: usize = 1; +fn aiur_fn_167( + inp: [G; IN_167], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_167], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = result.output.try_into().unwrap(); __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = __r_arr[10]; + let __v_32: G = __r_arr[11]; + let __v_33: G = __r_arr[12]; + let __v_34: G = __r_arr[13]; + let __v_35: G = __r_arr[14]; + let __v_36: G = __r_arr[15]; + let __v_37: G = __r_arr[16]; + let __v_38: G = __r_arr[17]; + match __v_21.as_canonical_u64() { + 9u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_39: G = __loaded[0]; + let __v_40: G = __loaded[1]; + let __v_41: G = __loaded[2]; + let __v_42: G = __loaded[3]; + let __v_43: G = __loaded[4]; + let __v_44: G = __loaded[5]; + let __v_45: G = __loaded[6]; + let __v_46: G = __loaded[7]; + let __v_47: G = __loaded[8]; + let __v_48: G = __loaded[9]; + let __v_49: G = __loaded[10]; + let __v_50: G = __loaded[11]; + let __v_51: G = __loaded[12]; + let __v_52: G = __loaded[13]; + let __v_53: G = __loaded[14]; + let __v_54: G = __loaded[15]; + let __v_55: G = __loaded[16]; + let __v_56: G = __loaded[17]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = result.output.try_into().unwrap(); __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __v_65: G = __r_arr[8]; + let __v_66: G = __r_arr[9]; + let __v_67: G = __r_arr[10]; + let __v_68: G = __r_arr[11]; + let __v_69: G = __r_arr[12]; + let __v_70: G = __r_arr[13]; + let __v_71: G = __r_arr[14]; + let __v_72: G = __r_arr[15]; + let __v_73: G = __r_arr[16]; + let __v_74: G = __r_arr[17]; + match __v_57.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __ret: [G; OUT_167] = [__v_76]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __v_78: G = G::from_u64(0); + let __v_79: G = G::from_u64(0); + let __v_80: G = G::from_u64(0); + let __v_81: G = G::from_u64(0); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = G::from_u64(0); + let __v_85: G = G::from_u64(0); + let __v_86: G = G::from_u64(0); + let __v_87: G = G::from_u64(0); + let __v_88: G = G::from_u64(0); + let __v_89: G = G::from_u64(0); + let __v_90: G = G::from_u64(0); + let __v_91: G = G::from_u64(0); + let __v_92: G = G::from_u64(0); + let __v_93: G = G::from_u64(0); + let __v_94: G = G::from_u64(0); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = G::from_u64(0); + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(0); + let __v_100: G = G::from_u64(0); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = G::from_u64(0); + let __v_104: G = G::from_u64(0); + let __v_105: G = G::from_u64(0); + let __v_106: G = G::from_u64(0); + let __v_107: G = { let __values: [G; 32] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_167] = [__v_107]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_167] = [__v_71]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_168: usize = 48; +const IN_168: usize = 48; +const OUT_168: usize = 2; +fn aiur_fn_168( + inp: [G; IN_168], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_168], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_48: G = __loaded[0]; + let __v_49: G = __loaded[1]; + let __v_50: G = __loaded[2]; + let __v_51: G = __loaded[3]; + let __v_52: G = __loaded[4]; + let __v_53: G = __loaded[5]; + let __v_54: G = __loaded[6]; + let __v_55: G = __loaded[7]; + let __v_56: G = __loaded[8]; + let __v_57: G = __loaded[9]; + let __v_58: G = __loaded[10]; + let __v_59: G = __loaded[11]; + let __v_60: G = __loaded[12]; + let __v_61: G = __loaded[13]; + let __v_62: G = __loaded[14]; + let __v_63: G = __loaded[15]; + let __v_64: G = __loaded[16]; + let __v_65: G = __loaded[17]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = (__v_66 + __v_67); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = (__v_68 + __v_69); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = (__v_70 + __v_71); + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_72, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = result.output.try_into().unwrap(); __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + let __v_81: G = __r_arr[7]; + let __v_82: G = __r_arr[8]; + let __v_83: G = __r_arr[9]; + let __v_84: G = __r_arr[10]; + let __v_85: G = __r_arr[11]; + let __v_86: G = __r_arr[12]; + let __v_87: G = __r_arr[13]; + let __v_88: G = __r_arr[14]; + let __v_89: G = __r_arr[15]; + let __v_90: G = __r_arr[16]; + let __v_91: G = __r_arr[17]; + let __v_92: G = __r_arr[18]; + let __v_93: G = __r_arr[19]; + let __v_94: G = __r_arr[20]; + let __v_95: G = __r_arr[21]; + let __v_96: G = __r_arr[22]; + let __v_97: G = __r_arr[23]; + let __v_98: G = __r_arr[24]; + let __v_99: G = __r_arr[25]; + let __v_100: G = __r_arr[26]; + let __v_101: G = __r_arr[27]; + let __v_102: G = __r_arr[28]; + let __v_103: G = __r_arr[29]; + let __v_104: G = __r_arr[30]; + let __v_105: G = __r_arr[31]; + let __v_106: G = __r_arr[32]; + let __v_107: G = __r_arr[33]; + let __v_108: G = __r_arr[34]; + let __v_109: G = __r_arr[35]; + let __v_110: G = __r_arr[36]; + let __v_111: G = __r_arr[37]; + let __v_112: G = __r_arr[38]; + let __v_113: G = __r_arr[39]; + let __v_114: G = __r_arr[40]; + let __v_115: G = __r_arr[41]; + let __v_116: G = __r_arr[42]; + let __v_117: G = __r_arr[43]; + let __v_118: G = __r_arr[44]; + let __v_119: G = __r_arr[45]; + let __v_120: G = __r_arr[46]; + let __v_121: G = __r_arr[47]; + match __v_74.as_canonical_u64() { + _ => { + match __v_74.as_canonical_u64() { + 6u64 => { + match __v_75.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_122: G = __r_arr[0]; + let __v_123: G = __r_arr[1]; + let __v_124: G = __r_arr[2]; + let __v_125: G = __r_arr[3]; + let __v_126: G = __r_arr[4]; + let __v_127: G = __r_arr[5]; + let __v_128: G = __r_arr[6]; + let __v_129: G = __r_arr[7]; + let __v_130: G = __r_arr[8]; + let __v_131: G = __r_arr[9]; + let __v_132: G = __r_arr[10]; + let __v_133: G = __r_arr[11]; + let __v_134: G = __r_arr[12]; + let __v_135: G = __r_arr[13]; + let __v_136: G = __r_arr[14]; + let __v_137: G = __r_arr[15]; + let __v_138: G = __r_arr[16]; + let __v_139: G = __r_arr[17]; + let __v_140: G = __r_arr[18]; + let __v_141: G = __r_arr[19]; + let __v_142: G = __r_arr[20]; + let __v_143: G = __r_arr[21]; + let __v_144: G = __r_arr[22]; + let __v_145: G = __r_arr[23]; + let __v_146: G = __r_arr[24]; + let __v_147: G = __r_arr[25]; + let __v_148: G = __r_arr[26]; + let __v_149: G = __r_arr[27]; + let __v_150: G = __r_arr[28]; + let __v_151: G = __r_arr[29]; + let __v_152: G = __r_arr[30]; + let __v_153: G = __r_arr[31]; + let __v_154: G = __r_arr[32]; + let __v_155: G = __r_arr[33]; + let __v_156: G = __r_arr[34]; + let __v_157: G = __r_arr[35]; + let __v_158: G = __r_arr[36]; + let __v_159: G = __r_arr[37]; + let __v_160: G = __r_arr[38]; + let __v_161: G = __r_arr[39]; + let __v_162: G = __r_arr[40]; + let __v_163: G = __r_arr[41]; + let __v_164: G = __r_arr[42]; + let __v_165: G = __r_arr[43]; + let __v_166: G = __r_arr[44]; + let __v_167: G = __r_arr[45]; + let __v_168: G = __r_arr[46]; + let __v_169: G = __r_arr[47]; + match __v_122.as_canonical_u64() { + _ => { + match __v_122.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_83, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_170: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_171: G = __r_arr[0]; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_123, __v_170, __v_171]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = result.output.try_into().unwrap(); __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __v_172: G = __r_arr[0]; + let __ret: [G; OUT_168] = [__v_172, __v_83]; + record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_122.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_74.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_169: usize = 3; +const IN_169: usize = 3; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_169], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = result.output.try_into().unwrap(); __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_169] = [__v_4]; + record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_170: usize = 4; +const IN_170: usize = 4; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_170], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + let __v_15: G = __loaded[11]; + let __v_16: G = __loaded[12]; + let __v_17: G = __loaded[13]; + let __v_18: G = __loaded[14]; + let __v_19: G = __loaded[15]; + let __v_20: G = __loaded[16]; + let __v_21: G = __loaded[17]; + let __v_22: G = __loaded[18]; + let __v_23: G = __loaded[19]; + let __v_24: G = __loaded[20]; + let __v_25: G = __loaded[21]; + let __v_26: G = __loaded[22]; + let __v_27: G = __loaded[23]; + let __v_28: G = __loaded[24]; + let __v_29: G = __loaded[25]; + let __v_30: G = __loaded[26]; + let __v_31: G = __loaded[27]; + let __v_32: G = __loaded[28]; + let __v_33: G = __loaded[29]; + let __v_34: G = __loaded[30]; + let __v_35: G = __loaded[31]; + let __v_36: G = __loaded[32]; + let __v_37: G = __loaded[33]; + let __v_38: G = __loaded[34]; + let __v_39: G = __loaded[35]; + let __v_40: G = __loaded[36]; + let __v_41: G = __loaded[37]; + let __v_42: G = __loaded[38]; + let __v_43: G = __loaded[39]; + let __v_44: G = __loaded[40]; + let __v_45: G = __loaded[41]; + let __v_46: G = __loaded[42]; + let __v_47: G = __loaded[43]; + let __v_48: G = __loaded[44]; + let __v_49: G = __loaded[45]; + let __v_50: G = __loaded[46]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_51: G = G::from_u64(1); + let __v_52: G = G::from_u64(1); + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_170] = [__v_53]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = (__v_3 - __v_2); + let __v_53: G = G::from_bool((__v_52 == G::ZERO)); + match __v_53.as_canonical_u64() { + 1u64 => { + match __v_5.as_canonical_u64() { + 1u64 => { + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_54, __v_1, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_170] = [__v_56]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_54: G = G::from_u64(1); + let __v_55: G = G::from_u64(1); + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_170] = [__v_56]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_54: G = (__v_1 + __v_51); + let __v_55: G = G::from_u64(1); + let __v_56: G = (__v_3 + __v_55); + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = result.output.try_into().unwrap(); __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_170] = [__v_57]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_171: usize = 57; +const IN_171: usize = 57; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_171], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_50, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = (__v_51 + __v_58); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_57, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(4); + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_37, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = result.output.try_into().unwrap(); __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_67]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = result.output.try_into().unwrap(); __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + match __v_57.as_canonical_u64() { + 1u64 => { + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50, __v_51, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = result.output.try_into().unwrap(); __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(3); + let __v_61: G = G::from_u64(0); + let __v_62: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_60, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = G::from_u64(1); + let __v_64: G = G::from_u64(1); + let __v_65: G = { let __values: [G; 3] = [__v_63, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = { let __values: [G; 3] = [__v_61, __v_62, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_66]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_45.as_canonical_u64() { + _ => { + break '__mc_0 [__v_45]; + }, +} + }; + let __v_58: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_53, __v_58, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = result.output.try_into().unwrap(); __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = G::from_u64(3); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_61, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_62, __v_63, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_67]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(1); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_57, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_60, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_65]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_172: usize = 7; +const IN_172: usize = 7; +const OUT_172: usize = 1; +fn aiur_fn_172( + inp: [G; IN_172], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_172], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __v_18: G = __loaded[11]; + let __v_19: G = __loaded[12]; + let __v_20: G = __loaded[13]; + let __v_21: G = __loaded[14]; + let __v_22: G = __loaded[15]; + let __v_23: G = __loaded[16]; + let __v_24: G = __loaded[17]; + let __v_25: G = __loaded[18]; + let __v_26: G = __loaded[19]; + let __v_27: G = __loaded[20]; + let __v_28: G = __loaded[21]; + let __v_29: G = __loaded[22]; + let __v_30: G = __loaded[23]; + let __v_31: G = __loaded[24]; + let __v_32: G = __loaded[25]; + let __v_33: G = __loaded[26]; + let __v_34: G = __loaded[27]; + let __v_35: G = __loaded[28]; + let __v_36: G = __loaded[29]; + let __v_37: G = __loaded[30]; + let __v_38: G = __loaded[31]; + let __v_39: G = __loaded[32]; + let __v_40: G = __loaded[33]; + let __v_41: G = __loaded[34]; + let __v_42: G = __loaded[35]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_43: G = G::from_u64(1); + let __v_44: G = G::from_u64(1); + let __v_45: G = { let __values: [G; 3] = [__v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_172] = [__v_45]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_43: G = G::from_u64(5); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 52] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_43, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_6, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = result.output.try_into().unwrap(); __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_172] = [__v_48]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_173: usize = 13; +const IN_173: usize = 13; +const OUT_173: usize = 1; +fn aiur_fn_173( + inp: [G; IN_173], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_173], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __v_31: G = __loaded[18]; + let __v_32: G = __loaded[19]; + let __v_33: G = __loaded[20]; + let __v_34: G = __loaded[21]; + let __v_35: G = __loaded[22]; + let __v_36: G = __loaded[23]; + let __v_37: G = __loaded[24]; + let __v_38: G = __loaded[25]; + let __v_39: G = __loaded[26]; + let __v_40: G = __loaded[27]; + let __v_41: G = __loaded[28]; + let __v_42: G = __loaded[29]; + let __v_43: G = __loaded[30]; + let __v_44: G = __loaded[31]; + let __v_45: G = __loaded[32]; + let __v_46: G = __loaded[33]; + let __v_47: G = __loaded[34]; + let __v_48: G = __loaded[35]; + let __v_49: G = __loaded[36]; + let __v_50: G = __loaded[37]; + let __v_51: G = __loaded[38]; + let __v_52: G = __loaded[39]; + let __v_53: G = __loaded[40]; + let __v_54: G = __loaded[41]; + let __v_55: G = __loaded[42]; + let __v_56: G = __loaded[43]; + let __v_57: G = __loaded[44]; + let __v_58: G = __loaded[45]; + let __v_59: G = __loaded[46]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + let __v_62: G = { let __values: [G; 3] = [__v_60, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_173] = [__v_62]; + record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = result.output.try_into().unwrap(); __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(1); + let __v_62: G = (__v_8 + __v_61); + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = result.output.try_into().unwrap(); __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_60, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_173] = [__v_64]; + record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_174: usize = 1; +const IN_174: usize = 1; +const OUT_174: usize = 2; +fn aiur_fn_174( + inp: [G; IN_174], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_174], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_174] = [__v_2, __v_3]; + record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_175: usize = 7; +const IN_175: usize = 7; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_175], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = result.output.try_into().unwrap(); __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __v_10: G = __r_arr[3]; + let __v_11: G = __r_arr[4]; + let __v_12: G = __r_arr[5]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = result.output.try_into().unwrap(); __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = __r_arr[3]; + let __v_17: G = __r_arr[4]; + let __v_18: G = __r_arr[5]; + let __v_19: G = { let __values: [G; 6] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_19, __v_3, __v_4, __v_5, __v_6, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_175] = [__v_23]; + record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_176: usize = 9; +const IN_176: usize = 9; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_176], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_176] = [__v_14]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + let __v_23: G = __loaded[11]; + let __v_24: G = __loaded[12]; + let __v_25: G = __loaded[13]; + let __v_26: G = __loaded[14]; + let __v_27: G = __loaded[15]; + let __v_28: G = __loaded[16]; + let __v_29: G = __loaded[17]; + let __v_30: G = __loaded[18]; + let __v_31: G = __loaded[19]; + let __v_32: G = __loaded[20]; + let __v_33: G = __loaded[21]; + let __v_34: G = __loaded[22]; + let __v_35: G = __loaded[23]; + let __v_36: G = __loaded[24]; + let __v_37: G = __loaded[25]; + let __v_38: G = __loaded[26]; + let __v_39: G = __loaded[27]; + let __v_40: G = __loaded[28]; + let __v_41: G = __loaded[29]; + let __v_42: G = __loaded[30]; + let __v_43: G = __loaded[31]; + let __v_44: G = __loaded[32]; + let __v_45: G = __loaded[33]; + let __v_46: G = __loaded[34]; + let __v_47: G = __loaded[35]; + let __v_48: G = __loaded[36]; + let __v_49: G = __loaded[37]; + let __v_50: G = __loaded[38]; + let __v_51: G = __loaded[39]; + let __v_52: G = __loaded[40]; + let __v_53: G = __loaded[41]; + let __v_54: G = __loaded[42]; + let __v_55: G = __loaded[43]; + let __v_56: G = __loaded[44]; + let __v_57: G = __loaded[45]; + let __v_58: G = __loaded[46]; + let __v_59: G = __loaded[47]; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = result.output.try_into().unwrap(); __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + _ => { + match __v_12.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() { + 0u64 => { + let __v_63: G = G::from_u64(0); + break '__mc_0 [__v_63]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_62, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + break '__mc_0 [__v_63]; + }, +} + }; + let __v_63: G = __mc_out___mc_0[0]; + match __v_63.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_64]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_62.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_8]; + }, + _ => { + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_62, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_1 [__v_65]; + }, +} + }; + let __v_64: G = __mc_out___mc_1[0]; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_60, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = result.output.try_into().unwrap(); __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_60, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = result.output.try_into().unwrap(); __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_66, __v_70]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = result.output.try_into().unwrap(); __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_13, __v_57, __v_68, __v_71, __v_69, __v_59, __v_13, __v_66, __v_72, __v_58, __v_2, __v_6, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = result.output.try_into().unwrap(); __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = (__v_7 + __v_65); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_76]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(1); + let __v_66: G = G::from_u64(1); + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 3] = [__v_64, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_60]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = result.output.try_into().unwrap(); __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_68, __v_63, __v_59, __v_70, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_69, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(1); + let __v_75: G = (__v_7 + __v_74); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_176] = [__v_77]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(1); + let __v_72: G = (__v_7 + __v_71); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_176] = [__v_74]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(2); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(1); + let __v_72: G = (__v_7 + __v_71); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_176] = [__v_74]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_58, __v_57, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = result.output.try_into().unwrap(); __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(1); + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = { let __values: [G; 3] = [__v_66, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(3); + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_70, __v_63, __v_59, __v_71, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_64, __v_65]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(1); + let __v_75: G = (__v_7 + __v_74); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_176] = [__v_77]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_177: usize = 10; +const IN_177: usize = 10; +const OUT_177: usize = 2; +fn aiur_fn_177( + inp: [G; IN_177], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_177], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_2, __v_3]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_15, __v_16]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(4); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __v_31: G = __loaded[18]; + let __v_32: G = __loaded[19]; + let __v_33: G = __loaded[20]; + let __v_34: G = __loaded[21]; + let __v_35: G = __loaded[22]; + let __v_36: G = __loaded[23]; + let __v_37: G = __loaded[24]; + let __v_38: G = __loaded[25]; + let __v_39: G = __loaded[26]; + let __v_40: G = __loaded[27]; + let __v_41: G = __loaded[28]; + let __v_42: G = __loaded[29]; + let __v_43: G = __loaded[30]; + let __v_44: G = __loaded[31]; + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __info = io_buffer.get_info(__v_12, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_45: G = __io_pair.0; + let __v_46: G = __io_pair.1; + let __v_47: G = G::from_u64(4); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_47, __v_45, __v_46]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_49: G = __loaded[0]; + let __v_50: G = __loaded[1]; + let __v_51: G = __loaded[2]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_49.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_50]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, +} + }; + let __v_52: G = __mc_out___mc_0[0]; + match __v_52.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_53: G = __loaded[0]; + let __v_54: G = __loaded[1]; + let __v_55: G = __loaded[2]; + match __v_53.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_2, __v_3]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_54, __v_55, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_56, __v_57]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + let __v_53: G = G::from_u64(0); + let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = __r_arr[3]; + let __v_66: G = __r_arr[4]; + let __v_67: G = __r_arr[5]; + let __v_68: G = __r_arr[6]; + let __v_69: G = __r_arr[7]; + let __v_70: G = __r_arr[8]; + let __v_71: G = __r_arr[9]; + let __v_72: G = __r_arr[10]; + let __v_73: G = __r_arr[11]; + let __v_74: G = __r_arr[12]; + let __v_75: G = __r_arr[13]; + let __v_76: G = __r_arr[14]; + let __v_77: G = __r_arr[15]; + let __v_78: G = __r_arr[16]; + let __v_79: G = __r_arr[17]; + let __v_80: G = __r_arr[18]; + let __v_81: G = __r_arr[19]; + let __v_82: G = __r_arr[20]; + let __v_83: G = __r_arr[21]; + let __v_84: G = __r_arr[22]; + let __v_85: G = __r_arr[23]; + let __v_86: G = __r_arr[24]; + let __v_87: G = __r_arr[25]; + let __v_88: G = __r_arr[26]; + let __v_89: G = __r_arr[27]; + let __v_90: G = __r_arr[28]; + let __v_91: G = __r_arr[29]; + let __v_92: G = __r_arr[30]; + let __v_93: G = __r_arr[31]; + let __v_94: G = __r_arr[32]; + let __v_95: G = __r_arr[33]; + let __v_96: G = __r_arr[34]; + let __v_97: G = __r_arr[35]; + let __v_98: G = __r_arr[36]; + let __v_99: G = __r_arr[37]; + let __v_100: G = __r_arr[38]; + let __v_101: G = __r_arr[39]; + let __v_102: G = __r_arr[40]; + let __v_103: G = __r_arr[41]; + let __v_104: G = __r_arr[42]; + let __v_105: G = __r_arr[43]; + let __v_106: G = __r_arr[44]; + let __v_107: G = __r_arr[45]; + let __v_108: G = __r_arr[46]; + let __v_109: G = __r_arr[47]; + let __v_110: G = G::from_u64(0); + let __v_111: G = { let __values: [G; 48] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + match __v_62.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = result.output.try_into().unwrap(); __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = G::from_u64(0); + let __v_115: G = G::from_u64(0); + let __v_116: G = G::from_u64(0); + let __v_117: G = G::from_u64(0); + let __v_118: G = G::from_u64(0); + let __v_119: G = G::from_u64(0); + let __v_120: G = G::from_u64(0); + let __v_121: G = G::from_u64(0); + let __v_122: G = G::from_u64(0); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = G::from_u64(0); + let __v_126: G = G::from_u64(0); + let __v_127: G = G::from_u64(0); + let __v_128: G = G::from_u64(0); + let __v_129: G = G::from_u64(0); + let __v_130: G = G::from_u64(0); + let __v_131: G = G::from_u64(0); + let __v_132: G = G::from_u64(0); + let __v_133: G = G::from_u64(0); + let __v_134: G = G::from_u64(0); + let __v_135: G = G::from_u64(0); + let __v_136: G = G::from_u64(0); + let __v_137: G = G::from_u64(0); + let __v_138: G = G::from_u64(0); + let __v_139: G = G::from_u64(0); + let __v_140: G = G::from_u64(0); + let __v_141: G = G::from_u64(0); + let __v_142: G = G::from_u64(0); + let __v_143: G = G::from_u64(0); + let __v_144: G = G::from_u64(0); + let __v_145: G = G::from_u64(0); + let __v_146: G = { let __values: [G; 32] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_113, __v_146]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_147: G = __r_arr[0]; + match __v_147.as_canonical_u64() { + 1u64 => { + let __v_148: G = G::from_u64(1); + let __v_149: G = G::from_u64(1); + let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_150]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_151: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_151, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_152: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_153: G = __loaded[0]; + let __v_154: G = __loaded[1]; + let __v_155: G = __loaded[2]; + match __v_153.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_54, __v_112]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_154, __v_155, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_156: G = __r_arr[0]; + let __v_157: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_156, __v_157]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_153.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_148: G = G::from_u64(0); + let __v_149: G = G::from_u64(1); + let __v_150: G = G::from_u64(1); + let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_152]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_153: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_153, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_154: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_155: G = __loaded[0]; + let __v_156: G = __loaded[1]; + let __v_157: G = __loaded[2]; + match __v_155.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_54, __v_112]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_156, __v_157, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_158: G = __r_arr[0]; + let __v_159: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_158, __v_159]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_155.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_147.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_178: usize = 1; +const IN_178: usize = 1; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: [G; IN_178], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_178], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = result.output.try_into().unwrap(); __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = result.output.try_into().unwrap(); __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = { let __values: [G; 6] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_12, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = result.output.try_into().unwrap(); __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_13, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = result.output.try_into().unwrap(); __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = result.output.try_into().unwrap(); __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = { let __values: [G; 6] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = result.output.try_into().unwrap(); __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_178] = [__v_37]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_179: usize = 5; +const IN_179: usize = 5; +const OUT_179: usize = 1; +fn aiur_fn_179( + inp: [G; IN_179], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_179], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_0 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_179] = [__v_8]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = result.output.try_into().unwrap(); __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_0 + __v_8); + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = result.output.try_into().unwrap(); __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_179] = [__v_11]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_180: usize = 1; +const IN_180: usize = 1; +const OUT_180: usize = 1; +fn aiur_fn_180( + inp: [G; IN_180], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_180], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + match __v_1.as_canonical_u64() { + _ => { + match __v_1.as_canonical_u64() { + 6u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_181: usize = 4; +const IN_181: usize = 4; +const OUT_181: usize = 2; +fn aiur_fn_181( + inp: [G; IN_181], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_181], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_181] = [__v_7, __v_40]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_11 - __v_0); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = result.output.try_into().unwrap(); __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_14 * __v_15); + match __v_16.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __ret: [G; OUT_181] = [__v_17, __v_5]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_6, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = result.output.try_into().unwrap(); __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_181] = [__v_17, __v_18]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_182: usize = 3; +const IN_182: usize = 3; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_182], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 32] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_182] = [__v_38]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_9: G = (__v_7 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_182] = [__v_4]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = result.output.try_into().unwrap(); __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_182] = [__v_10]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_183: usize = 4; +const IN_183: usize = 4; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: [G; IN_183], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_183], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = result.output.try_into().unwrap(); __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_183] = [__v_5]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = result.output.try_into().unwrap(); __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_183] = [__v_6]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_184: usize = 10; +const IN_184: usize = 10; +const OUT_184: usize = 6; +fn aiur_fn_184( + inp: [G; IN_184], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_184], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_184] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = result.output.try_into().unwrap(); __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_19 - __v_3); + match __v_20.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = __r_arr[3]; + let __v_31: G = __r_arr[4]; + let __v_32: G = __r_arr[5]; + let __ret: [G; OUT_184] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __ret: [G; OUT_184] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_185: usize = 3; +const IN_185: usize = 3; +const OUT_185: usize = 6; +fn aiur_fn_185( + inp: [G; IN_185], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_185], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_12, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = __r_arr[3]; + let __v_17: G = __r_arr[4]; + let __v_18: G = __r_arr[5]; + let __ret: [G; OUT_185] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_186: usize = 7; +const IN_186: usize = 7; +const OUT_186: usize = 6; +fn aiur_fn_186( + inp: [G; IN_186], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_186], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_186] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = result.output.try_into().unwrap(); __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __ret: [G; OUT_186] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_187: usize = 9; +const IN_187: usize = 9; +const OUT_187: usize = 1; +fn aiur_fn_187( + inp: [G; IN_187], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_187], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = (__v_1 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_187] = [__v_12]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_0 + __v_12); + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = result.output.try_into().unwrap(); __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_10, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_187] = [__v_15]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_188: usize = 3; +const IN_188: usize = 3; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_188], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_188] = [__v_8]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __v_17: G = __loaded[11]; + let __v_18: G = __loaded[12]; + let __v_19: G = __loaded[13]; + let __v_20: G = __loaded[14]; + let __v_21: G = __loaded[15]; + let __v_22: G = __loaded[16]; + let __v_23: G = __loaded[17]; + let __v_24: G = __loaded[18]; + let __v_25: G = __loaded[19]; + let __v_26: G = __loaded[20]; + let __v_27: G = __loaded[21]; + let __v_28: G = __loaded[22]; + let __v_29: G = __loaded[23]; + let __v_30: G = __loaded[24]; + let __v_31: G = __loaded[25]; + let __v_32: G = __loaded[26]; + let __v_33: G = __loaded[27]; + let __v_34: G = __loaded[28]; + let __v_35: G = __loaded[29]; + let __v_36: G = __loaded[30]; + let __v_37: G = __loaded[31]; + let __v_38: G = __loaded[32]; + let __v_39: G = __loaded[33]; + let __v_40: G = __loaded[34]; + let __v_41: G = __loaded[35]; + let __v_42: G = __loaded[36]; + let __v_43: G = __loaded[37]; + let __v_44: G = __loaded[38]; + let __v_45: G = __loaded[39]; + let __v_46: G = __loaded[40]; + let __v_47: G = __loaded[41]; + let __v_48: G = __loaded[42]; + let __v_49: G = __loaded[43]; + let __v_50: G = __loaded[44]; + let __v_51: G = __loaded[45]; + let __v_52: G = __loaded[46]; + let __v_53: G = __loaded[47]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_54: G = __loaded[0]; + let __v_55: G = __loaded[1]; + let __v_56: G = __loaded[2]; + match __v_54.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + _ => { + match __v_6.as_canonical_u64() { + 6u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __v_64: G = __r_arr[6]; + let __v_65: G = __r_arr[7]; + let __v_66: G = __r_arr[8]; + let __v_67: G = __r_arr[9]; + let __v_68: G = __r_arr[10]; + let __v_69: G = __r_arr[11]; + let __v_70: G = __r_arr[12]; + let __v_71: G = __r_arr[13]; + let __v_72: G = __r_arr[14]; + let __v_73: G = __r_arr[15]; + let __v_74: G = __r_arr[16]; + let __v_75: G = __r_arr[17]; + let __v_76: G = __r_arr[18]; + let __v_77: G = __r_arr[19]; + let __v_78: G = __r_arr[20]; + let __v_79: G = __r_arr[21]; + let __v_80: G = __r_arr[22]; + let __v_81: G = __r_arr[23]; + let __v_82: G = __r_arr[24]; + let __v_83: G = __r_arr[25]; + let __v_84: G = __r_arr[26]; + let __v_85: G = __r_arr[27]; + let __v_86: G = __r_arr[28]; + let __v_87: G = __r_arr[29]; + let __v_88: G = __r_arr[30]; + let __v_89: G = __r_arr[31]; + let __v_90: G = __r_arr[32]; + let __v_91: G = __r_arr[33]; + let __v_92: G = __r_arr[34]; + let __v_93: G = __r_arr[35]; + let __v_94: G = __r_arr[36]; + let __v_95: G = __r_arr[37]; + let __v_96: G = __r_arr[38]; + let __v_97: G = __r_arr[39]; + let __v_98: G = __r_arr[40]; + let __v_99: G = __r_arr[41]; + let __v_100: G = __r_arr[42]; + let __v_101: G = __r_arr[43]; + let __v_102: G = __r_arr[44]; + let __v_103: G = __r_arr[45]; + let __v_104: G = __r_arr[46]; + let __v_105: G = __r_arr[47]; + match __v_58.as_canonical_u64() { + _ => { + match __v_58.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_106: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_59, __v_106]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(1); + let __v_109: G = (__v_107 + __v_108); + let __v_110: G = (__v_57 + __v_109); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_59, __v_111]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = result.output.try_into().unwrap(); __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __v_112: G = __r_arr[0]; + let __v_113: G = G::from_u64(0); + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_110, __v_112, __v_113]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = result.output.try_into().unwrap(); __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __v_114: G = __r_arr[0]; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_114, __v_115]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = result.output.try_into().unwrap(); __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __v_116: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_116]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __v_106: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_106]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_57]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_54.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_189: usize = 2; +const IN_189: usize = 2; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_189], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = result.output.try_into().unwrap(); __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_189] = [__v_3]; + record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_190: usize = 3; +const IN_190: usize = 3; +const OUT_190: usize = 1; +fn aiur_fn_190( + inp: [G; IN_190], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_190], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + let __v_14: G = __loaded[11]; + let __v_15: G = __loaded[12]; + let __v_16: G = __loaded[13]; + let __v_17: G = __loaded[14]; + let __v_18: G = __loaded[15]; + let __v_19: G = __loaded[16]; + let __v_20: G = __loaded[17]; + let __v_21: G = __loaded[18]; + let __v_22: G = __loaded[19]; + let __v_23: G = __loaded[20]; + let __v_24: G = __loaded[21]; + let __v_25: G = __loaded[22]; + let __v_26: G = __loaded[23]; + let __v_27: G = __loaded[24]; + let __v_28: G = __loaded[25]; + let __v_29: G = __loaded[26]; + let __v_30: G = __loaded[27]; + let __v_31: G = __loaded[28]; + let __v_32: G = __loaded[29]; + let __v_33: G = __loaded[30]; + let __v_34: G = __loaded[31]; + let __v_35: G = __loaded[32]; + let __v_36: G = __loaded[33]; + let __v_37: G = __loaded[34]; + let __v_38: G = __loaded[35]; + let __v_39: G = __loaded[36]; + let __v_40: G = __loaded[37]; + let __v_41: G = __loaded[38]; + let __v_42: G = __loaded[39]; + let __v_43: G = __loaded[40]; + let __v_44: G = __loaded[41]; + let __v_45: G = __loaded[42]; + let __v_46: G = __loaded[43]; + let __v_47: G = __loaded[44]; + let __v_48: G = __loaded[45]; + let __v_49: G = __loaded[46]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_50: G = G::from_u64(0); + let __ret: [G; OUT_190] = [__v_50]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_50: G = (__v_2 - __v_1); + match __v_50.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 1u64 => { + match __v_5.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __ret: [G; OUT_190] = [__v_51]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_51: G = G::from_u64(0); + let __ret: [G; OUT_190] = [__v_51]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_51: G = G::from_u64(1); + let __v_52: G = (__v_2 + __v_51); + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_49, __v_1, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = result.output.try_into().unwrap(); __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __ret: [G; OUT_190] = [__v_53]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_191: usize = 12; +const IN_191: usize = 12; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_191], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = (__v_10 - __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_191] = [__v_15]; + record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = result.output.try_into().unwrap(); __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __v_15: G = (__v_9 + __v_11); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_11 + __v_16); + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = result.output.try_into().unwrap(); __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 4] = [__v_14, __v_15, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_191] = [__v_19]; + record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_192: usize = 10; +const IN_192: usize = 10; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_192], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(4); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(1); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_17, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_9, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_21, __v_24, __v_27, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_192] = [__v_32]; + record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_193: usize = 1; +const IN_193: usize = 1; +const OUT_193: usize = 2; +fn aiur_fn_193( + inp: [G; IN_193], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_193], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = result.output.try_into().unwrap(); __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_193] = [__v_14, __v_15]; + record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_194: usize = 1; +const IN_194: usize = 1; +const OUT_194: usize = 2; +fn aiur_fn_194( + inp: [G; IN_194], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_194], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = result.output.try_into().unwrap(); __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __ret: [G; OUT_194] = [__v_4, __v_5]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = result.output.try_into().unwrap(); __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_194] = [__v_14, __v_15]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_195: usize = 2; +const IN_195: usize = 2; +const OUT_195: usize = 2; +fn aiur_fn_195( + inp: [G; IN_195], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_195], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = result.output.try_into().unwrap(); __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = result.output.try_into().unwrap(); __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = { let __values: [G; 6] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = result.output.try_into().unwrap(); __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = result.output.try_into().unwrap(); __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = result.output.try_into().unwrap(); __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __v_22: G = { let __values: [G; 6] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = result.output.try_into().unwrap(); __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = result.output.try_into().unwrap(); __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __v_28: G = __r_arr[2]; + let __v_29: G = __r_arr[3]; + let __v_30: G = __r_arr[4]; + let __v_31: G = __r_arr[5]; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1, __v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = result.output.try_into().unwrap(); __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_72, __v_5, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = result.output.try_into().unwrap(); __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = result.output.try_into().unwrap(); __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_25, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __ret: [G; OUT_195] = [__v_76, __v_77]; + record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_196: usize = 0; +const IN_196: usize = 0; +const OUT_196: usize = 2; +fn aiur_fn_196( + inp: [G; IN_196], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_196], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = result.output.try_into().unwrap(); __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_0: G = __r_arr[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 4] = [__v_1, __v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 11] = [__v_7, __v_8, __v_6, __v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = result.output.try_into().unwrap(); __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_196] = [__v_13, __v_0]; + record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_197: usize = 0; +const IN_197: usize = 0; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: [G; IN_197], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_197], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = result.output.try_into().unwrap(); __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = result.output.try_into().unwrap(); __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = result.output.try_into().unwrap(); __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = result.output.try_into().unwrap(); __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = result.output.try_into().unwrap(); __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = result.output.try_into().unwrap(); __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = result.output.try_into().unwrap(); __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(0); + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = result.output.try_into().unwrap(); __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(0); + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = result.output.try_into().unwrap(); __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = result.output.try_into().unwrap(); __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = result.output.try_into().unwrap(); __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = result.output.try_into().unwrap(); __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = G::from_u64(0); + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = result.output.try_into().unwrap(); __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = result.output.try_into().unwrap(); __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = G::from_u64(0); + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = result.output.try_into().unwrap(); __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(0); + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = G::from_u64(0); + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = G::from_u64(0); + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = G::from_u64(0); + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = G::from_u64(0); + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __v_80: G = G::from_u64(0); + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __v_82: G = G::from_u64(0); + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __v_84: G = G::from_u64(0); + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_85: G = __r_arr[0]; + let __v_86: G = G::from_u64(0); + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __v_87: G = __r_arr[0]; + let __v_88: G = G::from_u64(0); + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_89: G = __r_arr[0]; + let __v_90: G = G::from_u64(0); + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = G::from_u64(0); + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_93: G = __r_arr[0]; + let __v_94: G = G::from_u64(0); + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __v_95: G = __r_arr[0]; + let __v_96: G = G::from_u64(0); + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_97: G = __r_arr[0]; + let __v_98: G = G::from_u64(0); + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_99: G = __r_arr[0]; + let __v_100: G = G::from_u64(0); + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_101: G = __r_arr[0]; + let __v_102: G = G::from_u64(0); + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_103: G = __r_arr[0]; + let __v_104: G = G::from_u64(0); + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_105: G = __r_arr[0]; + let __v_106: G = G::from_u64(0); + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(0); + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = G::from_u64(0); + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __v_112: G = G::from_u64(0); + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = result.output.try_into().unwrap(); __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = G::from_u64(0); + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(0); + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __v_118: G = G::from_u64(0); + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_119: G = __r_arr[0]; + let __v_120: G = G::from_u64(0); + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_121: G = __r_arr[0]; + let __v_122: G = G::from_u64(0); + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = result.output.try_into().unwrap(); __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __v_123: G = __r_arr[0]; + let __v_124: G = G::from_u64(0); + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_125: G = __r_arr[0]; + let __v_126: G = G::from_u64(0); + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = result.output.try_into().unwrap(); __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __v_127: G = __r_arr[0]; + let __v_128: G = G::from_u64(0); + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = result.output.try_into().unwrap(); __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __v_129: G = __r_arr[0]; + let __v_130: G = G::from_u64(0); + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = result.output.try_into().unwrap(); __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_131: G = __r_arr[0]; + let __v_132: G = G::from_u64(0); + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = result.output.try_into().unwrap(); __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __v_133: G = __r_arr[0]; + let __v_134: G = G::from_u64(0); + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_135: G = __r_arr[0]; + let __v_136: G = G::from_u64(0); + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_137: G = __r_arr[0]; + let __v_138: G = G::from_u64(1); + let __v_139: G = G::from_u64(1); + let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_141: G = { let __values: [G; 3] = [__v_136, __v_137, __v_140]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_142: G = { let __values: [G; 3] = [__v_134, __v_135, __v_141]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = { let __values: [G; 3] = [__v_132, __v_133, __v_142]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_144: G = { let __values: [G; 3] = [__v_130, __v_131, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_145: G = { let __values: [G; 3] = [__v_128, __v_129, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_146: G = { let __values: [G; 3] = [__v_126, __v_127, __v_145]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_147: G = { let __values: [G; 3] = [__v_124, __v_125, __v_146]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_148: G = { let __values: [G; 3] = [__v_122, __v_123, __v_147]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_149: G = { let __values: [G; 3] = [__v_120, __v_121, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_150: G = { let __values: [G; 3] = [__v_118, __v_119, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_151: G = { let __values: [G; 3] = [__v_116, __v_117, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_152: G = { let __values: [G; 3] = [__v_114, __v_115, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_153: G = { let __values: [G; 3] = [__v_112, __v_113, __v_152]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_154: G = { let __values: [G; 3] = [__v_110, __v_111, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_155: G = { let __values: [G; 3] = [__v_108, __v_109, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_156: G = { let __values: [G; 3] = [__v_106, __v_107, __v_155]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_157: G = { let __values: [G; 3] = [__v_104, __v_105, __v_156]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_158: G = { let __values: [G; 3] = [__v_102, __v_103, __v_157]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_159: G = { let __values: [G; 3] = [__v_100, __v_101, __v_158]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_160: G = { let __values: [G; 3] = [__v_98, __v_99, __v_159]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_161: G = { let __values: [G; 3] = [__v_96, __v_97, __v_160]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_162: G = { let __values: [G; 3] = [__v_94, __v_95, __v_161]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_163: G = { let __values: [G; 3] = [__v_92, __v_93, __v_162]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_164: G = { let __values: [G; 3] = [__v_90, __v_91, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_165: G = { let __values: [G; 3] = [__v_88, __v_89, __v_164]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_166: G = { let __values: [G; 3] = [__v_86, __v_87, __v_165]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_167: G = { let __values: [G; 3] = [__v_84, __v_85, __v_166]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_82, __v_83, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_169: G = { let __values: [G; 3] = [__v_80, __v_81, __v_168]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_170: G = { let __values: [G; 3] = [__v_78, __v_79, __v_169]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_171: G = { let __values: [G; 3] = [__v_76, __v_77, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_172: G = { let __values: [G; 3] = [__v_74, __v_75, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_173: G = { let __values: [G; 3] = [__v_72, __v_73, __v_172]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_174: G = { let __values: [G; 3] = [__v_70, __v_71, __v_173]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_175: G = { let __values: [G; 3] = [__v_68, __v_69, __v_174]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_176: G = { let __values: [G; 3] = [__v_66, __v_67, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_177: G = { let __values: [G; 3] = [__v_64, __v_65, __v_176]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_178: G = { let __values: [G; 3] = [__v_62, __v_63, __v_177]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_179: G = { let __values: [G; 3] = [__v_60, __v_61, __v_178]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_180: G = { let __values: [G; 3] = [__v_58, __v_59, __v_179]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_181: G = { let __values: [G; 3] = [__v_56, __v_57, __v_180]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_182: G = { let __values: [G; 3] = [__v_54, __v_55, __v_181]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_183: G = { let __values: [G; 3] = [__v_52, __v_53, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_184: G = { let __values: [G; 3] = [__v_50, __v_51, __v_183]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_185: G = { let __values: [G; 3] = [__v_48, __v_49, __v_184]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_186: G = { let __values: [G; 3] = [__v_46, __v_47, __v_185]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_187: G = { let __values: [G; 3] = [__v_44, __v_45, __v_186]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_188: G = { let __values: [G; 3] = [__v_42, __v_43, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_189: G = { let __values: [G; 3] = [__v_40, __v_41, __v_188]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_190: G = { let __values: [G; 3] = [__v_38, __v_39, __v_189]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_36, __v_37, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_192: G = { let __values: [G; 3] = [__v_34, __v_35, __v_191]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_193: G = { let __values: [G; 3] = [__v_32, __v_33, __v_192]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_194: G = { let __values: [G; 3] = [__v_30, __v_31, __v_193]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_28, __v_29, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_196: G = { let __values: [G; 3] = [__v_26, __v_27, __v_195]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_197: G = { let __values: [G; 3] = [__v_24, __v_25, __v_196]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_198: G = { let __values: [G; 3] = [__v_22, __v_23, __v_197]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_199: G = { let __values: [G; 3] = [__v_20, __v_21, __v_198]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_200: G = { let __values: [G; 3] = [__v_18, __v_19, __v_199]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_201: G = { let __values: [G; 3] = [__v_16, __v_17, __v_200]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_202: G = { let __values: [G; 3] = [__v_14, __v_15, __v_201]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_203: G = { let __values: [G; 3] = [__v_12, __v_13, __v_202]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_204: G = { let __values: [G; 3] = [__v_10, __v_11, __v_203]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_205: G = { let __values: [G; 3] = [__v_8, __v_9, __v_204]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_206: G = { let __values: [G; 3] = [__v_6, __v_7, __v_205]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_207: G = { let __values: [G; 3] = [__v_4, __v_5, __v_206]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_208: G = { let __values: [G; 3] = [__v_2, __v_3, __v_207]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_209: G = { let __values: [G; 3] = [__v_0, __v_1, __v_208]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_197] = [__v_209]; + record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: [G; IN_198], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_198], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_198] = [__v_4]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_4 + __v_5); + let __ret: [G; OUT_198] = [__v_6]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_199: usize = 2; +const IN_199: usize = 2; +const OUT_199: usize = 1; +fn aiur_fn_199( + inp: [G; IN_199], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_199], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_199] = [__v_4]; + record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = (__v_1 - __v_3); + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = result.output.try_into().unwrap(); __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_199] = [__v_6]; + record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_200], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_200] = [__v_5, __v_7]; + record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_200] = [__v_0, __v_7]; + record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_201: usize = 3; +const IN_201: usize = 3; +const OUT_201: usize = 1; +fn aiur_fn_201( + inp: [G; IN_201], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_201], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_3: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_201] = [__v_6]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_202: usize = 6; +const IN_202: usize = 6; +const OUT_202: usize = 1; +fn aiur_fn_202( + inp: [G; IN_202], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_202], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_9]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 * __v_19); + let __ret: [G; OUT_202] = [__v_20]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 * __v_19); + let __ret: [G; OUT_202] = [__v_20]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_3.as_canonical_u64() { + 4u64 => { + let __v_6: G = (__v_1 - __v_4); + let __v_7: G = G::from_bool((__v_6 == G::ZERO)); + let __ret: [G; OUT_202] = [__v_7]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_203: usize = 2; +const IN_203: usize = 2; +const OUT_203: usize = 1; +fn aiur_fn_203( + inp: [G; IN_203], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_203], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_203] = [__v_9]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(2); + let __ret: [G; OUT_203] = [__v_10]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_203] = [__v_10]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_204: usize = 2; +const IN_204: usize = 2; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_204], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_204] = [__v_5]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_204] = [__v_8]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_204] = [__v_9]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_204] = [__v_10]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_204] = [__v_10]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_205: usize = 2; +const IN_205: usize = 2; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_205], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = result.output.try_into().unwrap(); __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_206: usize = 2; +const IN_206: usize = 2; +const OUT_206: usize = 2; +fn aiur_fn_206( + inp: [G; IN_206], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_206], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_206] = [__v_5, __v_10]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_206] = [__v_6, __v_8]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_206] = [__v_7, __v_1]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_206] = [__v_7, __v_10]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_207: usize = 3; +const IN_207: usize = 3; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_207], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_11]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_11]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = result.output.try_into().unwrap(); __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_12]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_13]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_207] = [__v_0]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_208: usize = 2; +const IN_208: usize = 2; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_208], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + match __v_10.as_canonical_u64() { + _ => { + let __v_12: G = (__v_8 - __v_10); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_9 - __v_11); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = result.output.try_into().unwrap(); __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_208] = [__v_14]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_14]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_13]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_209: usize = 1; +const IN_209: usize = 1; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_209], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_209] = [__v_4]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + match __v_4.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = result.output.try_into().unwrap(); __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_209] = [__v_5]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_209] = [__v_6]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_210: usize = 2; +const IN_210: usize = 2; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_210], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_210] = [__v_0]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_210] = [__v_0]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + match __v_10.as_canonical_u64() { + _ => { + let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_210] = [__v_15]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_210] = [__v_14]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_210] = [__v_17]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_210] = [__v_15]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_211: usize = 3; +const IN_211: usize = 3; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: [G; IN_211], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_211], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_211] = [__v_0]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_211] = [__v_6]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_211] = [__v_0]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_211] = [__v_3]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_212: usize = 3; +const IN_212: usize = 3; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_212], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_14]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_13]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_212] = [__v_0]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_15]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_12]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_213: usize = 4; +const IN_213: usize = 4; +const OUT_213: usize = 1; +fn aiur_fn_213( + inp: [G; IN_213], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_213], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_213] = [__v_19]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = result.output.try_into().unwrap(); __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_213] = [__v_14]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_213] = [__v_20]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_213] = [__v_13]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_214: usize = 6; +const IN_214: usize = 6; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: [G; IN_214], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_214], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_6]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_4 + __v_9); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_11]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_3, __v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_13]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_12]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_7, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_9]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_214] = [__v_5]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_3, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_8]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 9; +const IN_215: usize = 9; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_215], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_9]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_7 + __v_12); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_6, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_15]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_9, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_16]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_16]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_10, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_10, __v_7, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_13]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_6, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_12]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_216: usize = 2; +const IN_216: usize = 2; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_216], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_216] = [__v_0]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = result.output.try_into().unwrap(); __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_216] = [__v_8]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_217] = [__v_0]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_217] = [__v_12]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = result.output.try_into().unwrap(); __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(0); + break '__mc_0 [__v_13]; + }, + _ => { + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + break '__mc_1 [__v_13]; + }, + 0u64 => { + let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + break '__mc_1 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + let __v_13: G = __mc_out___mc_1[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + break '__mc_2 [__v_17]; + }, + 0u64 => { + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = result.output.try_into().unwrap(); __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_17 + __v_18); + let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + break '__mc_2 [__v_20]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, +} + }; + let __v_17: G = __mc_out___mc_2[0]; + let __v_18: G = (__v_13 * __v_17); + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + break '__mc_0 [__v_19]; + }, + _ => { + break '__mc_0 [__v_6]; + }, + } + }, +} + }; + let __v_13: G = __mc_out___mc_0[0]; + let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() { + 1u64 => { + break '__mc_3 [__v_7]; + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + match __v_14.as_canonical_u64() { + 1u64 => { + break '__mc_3 [__v_7]; + }, + 0u64 => { + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + break '__mc_3 [__v_17]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + let __v_14: G = __mc_out___mc_3[0]; + let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_15, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_217] = [__v_16]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_218], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = (__v_9 - __v_12); + match __v_15.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = result.output.try_into().unwrap(); __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = result.output.try_into().unwrap(); __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_218] = [__v_17]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_17]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_16]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_15]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_219: usize = 3; +const IN_219: usize = 3; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: [G; IN_219], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_219], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_219] = [__v_6]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_219] = [__v_10]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(1); + break '__mc_0 [__v_11]; + }, + 1u64 => { + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = result.output.try_into().unwrap(); __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_219] = [__v_12]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_219] = [__v_12]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_220: usize = 2; +const IN_220: usize = 2; +const OUT_220: usize = 1; +fn aiur_fn_220( + inp: [G; IN_220], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_220], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_220] = [__v_5]; + record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + match __v_5.as_canonical_u64() { + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_6 + __v_7); + let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_220] = [__v_10]; + record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = result.output.try_into().unwrap(); __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_220] = [__v_10]; + record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_221: usize = 4; +const IN_221: usize = 4; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_221], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_221] = [__v_7]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_221] = [__v_11]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_221] = [__v_12]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_221] = [__v_12]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_222: usize = 3; +const IN_222: usize = 3; +const OUT_222: usize = 1; +fn aiur_fn_222( + inp: [G; IN_222], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_222], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_222] = [__v_6]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __v_8: G = (__v_6 - __v_1); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_222] = [__v_10]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_222] = [__v_10]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_222] = [__v_9]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_223: usize = 2; +const IN_223: usize = 2; +const OUT_223: usize = 1; +fn aiur_fn_223( + inp: [G; IN_223], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_223], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_223] = [__v_5]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + _ => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, +} + }; + let __v_8: G = __mc_out___mc_0[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_223] = [__v_9]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_7, __v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = result.output.try_into().unwrap(); __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_223] = [__v_10]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = result.output.try_into().unwrap(); __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_223] = [__v_10]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_224: usize = 3; +const IN_224: usize = 3; +const OUT_224: usize = 1; +fn aiur_fn_224( + inp: [G; IN_224], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_224], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_224] = [__v_6]; + record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_224] = [__v_9]; + record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = result.output.try_into().unwrap(); __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_224] = [__v_9]; + record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_225: usize = 3; +const IN_225: usize = 3; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_225], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_3, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_18, __v_19, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_20, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = result.output.try_into().unwrap(); __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_225] = [__v_21]; + record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_226: usize = 6; +const IN_226: usize = 6; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_226], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_226] = [__v_7]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_226] = [__v_7]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = result.output.try_into().unwrap(); __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_226] = [__v_9]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_227: usize = 6; +const IN_227: usize = 6; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_227], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_227] = [__v_7]; + record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = result.output.try_into().unwrap(); __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_227] = [__v_9]; + record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_228: usize = 6; +const IN_228: usize = 6; +const OUT_228: usize = 3; +fn aiur_fn_228( + inp: [G; IN_228], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_228], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_228] = [__v_3, __v_4, __v_5]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_228] = [__v_0, __v_1, __v_2]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_228] = [__v_0, __v_1, __v_2]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = G::from_u64(1); + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_228] = [__v_13, __v_17, __v_18]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(2); + let __v_11: G = { let __values: [G; 3] = [__v_0, __v_1, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_3, __v_4, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_228] = [__v_10, __v_11, __v_12]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(2); + let __v_8: G = { let __values: [G; 3] = [__v_0, __v_1, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_3, __v_4, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_228] = [__v_7, __v_8, __v_9]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_229: usize = 6; +const IN_229: usize = 6; +const OUT_229: usize = 3; +fn aiur_fn_229( + inp: [G; IN_229], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_229], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_229] = [__v_6, __v_7, __v_7]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __ret: [G; OUT_229] = [__v_6, __v_7, __v_8]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __ret: [G; OUT_229] = [__v_7, __v_8, __v_9]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_229] = [__v_3, __v_4, __v_5]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_229] = [__v_0, __v_1, __v_2]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(3); + let __v_9: G = { let __values: [G; 3] = [__v_0, __v_1, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_4, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_229] = [__v_8, __v_9, __v_10]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_230: usize = 3; +const IN_230: usize = 3; +const OUT_230: usize = 3; +fn aiur_fn_230( + inp: [G; IN_230], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_230], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_3, __v_4, __v_4]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_3: G = G::from_u64(4); + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_3, __v_1, __v_4]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = G::from_u64(1); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_6, __v_10, __v_11]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __ret: [G; OUT_230] = [__v_15, __v_16, __v_17]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __ret: [G; OUT_230] = [__v_15, __v_16, __v_17]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_231: usize = 4; +const IN_231: usize = 4; +const OUT_231: usize = 3; +fn aiur_fn_231( + inp: [G; IN_231], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_231], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_231] = [__v_4, __v_5, __v_5]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_231] = [__v_7, __v_11, __v_12]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __ret: [G; OUT_231] = [__v_16, __v_17, __v_18]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __ret: [G; OUT_231] = [__v_16, __v_17, __v_18]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __ret: [G; OUT_231] = [__v_5, __v_6, __v_7]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 1; +fn aiur_fn_232( + inp: [G; IN_232], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_232], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_232] = [__v_7]; + record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = { let __values: [G; 3] = [__v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = result.output.try_into().unwrap(); __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = { let __values: [G; 3] = [__v_8, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_232] = [__v_14]; + record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_233: usize = 2; +const IN_233: usize = 2; +const OUT_233: usize = 1; +fn aiur_fn_233( + inp: [G; IN_233], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_233], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_233] = [__v_0]; + record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = result.output.try_into().unwrap(); __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_233] = [__v_5]; + record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_234: usize = 2; +const IN_234: usize = 2; +const OUT_234: usize = 1; +fn aiur_fn_234( + inp: [G; IN_234], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_234], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_7, __v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_9, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_15]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_6: G = G::from_u64(2); + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = result.output.try_into().unwrap(); __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_9]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_6: G = G::from_u64(3); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_6: G = G::from_u64(4); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_6: G = G::from_u64(5); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_6: G = G::from_u64(6); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_6: G = G::from_u64(8); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 1; +fn aiur_fn_235( + inp: [G; IN_235], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_235], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[6].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = result.output.try_into().unwrap(); __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_235] = [__v_23]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_23]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_236: usize = 2; +const IN_236: usize = 2; +const OUT_236: usize = 1; +fn aiur_fn_236( + inp: [G; IN_236], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_236], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = (__v_3 - __v_6); + match __v_8.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_236] = [__v_9]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_9]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_237: usize = 4; +const IN_237: usize = 4; +const OUT_237: usize = 1; +fn aiur_fn_237( + inp: [G; IN_237], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_237], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_238: usize = 0; +const IN_238: usize = 0; +const OUT_238: usize = 1; +fn aiur_fn_238( + inp: [G; IN_238], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_238], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(171); + let __v_1: G = G::from_u64(104); + let __v_2: G = G::from_u64(44); + let __v_3: G = G::from_u64(23); + let __v_4: G = G::from_u64(120); + let __v_5: G = G::from_u64(161); + let __v_6: G = G::from_u64(123); + let __v_7: G = G::from_u64(190); + let __v_8: G = G::from_u64(174); + let __v_9: G = G::from_u64(64); + let __v_10: G = G::from_u64(50); + let __v_11: G = G::from_u64(151); + let __v_12: G = G::from_u64(77); + let __v_13: G = G::from_u64(243); + let __v_14: G = G::from_u64(100); + let __v_15: G = G::from_u64(71); + let __v_16: G = G::from_u64(206); + let __v_17: G = G::from_u64(139); + let __v_18: G = G::from_u64(252); + let __v_19: G = G::from_u64(171); + let __v_20: G = G::from_u64(103); + let __v_21: G = G::from_u64(100); + let __v_22: G = G::from_u64(163); + let __v_23: G = G::from_u64(109); + let __v_24: G = G::from_u64(55); + let __v_25: G = G::from_u64(133); + let __v_26: G = G::from_u64(102); + let __v_27: G = G::from_u64(227); + let __v_28: G = G::from_u64(173); + let __v_29: G = G::from_u64(99); + let __v_30: G = G::from_u64(202); + let __v_31: G = G::from_u64(184); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_238] = [__v_32]; + record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_239: usize = 0; +const IN_239: usize = 0; +const OUT_239: usize = 1; +fn aiur_fn_239( + inp: [G; IN_239], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_239], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(136); + let __v_1: G = G::from_u64(38); + let __v_2: G = G::from_u64(102); + let __v_3: G = G::from_u64(119); + let __v_4: G = G::from_u64(254); + let __v_5: G = G::from_u64(231); + let __v_6: G = G::from_u64(116); + let __v_7: G = G::from_u64(209); + let __v_8: G = G::from_u64(9); + let __v_9: G = G::from_u64(134); + let __v_10: G = G::from_u64(126); + let __v_11: G = G::from_u64(75); + let __v_12: G = G::from_u64(34); + let __v_13: G = G::from_u64(64); + let __v_14: G = G::from_u64(40); + let __v_15: G = G::from_u64(26); + let __v_16: G = G::from_u64(162); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(18); + let __v_19: G = G::from_u64(217); + let __v_20: G = G::from_u64(121); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(193); + let __v_23: G = G::from_u64(23); + let __v_24: G = G::from_u64(28); + let __v_25: G = G::from_u64(245); + let __v_26: G = G::from_u64(193); + let __v_27: G = G::from_u64(246); + let __v_28: G = G::from_u64(200); + let __v_29: G = G::from_u64(125); + let __v_30: G = G::from_u64(236); + let __v_31: G = G::from_u64(246); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_239] = [__v_32]; + record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_240: usize = 0; +const IN_240: usize = 0; +const OUT_240: usize = 1; +fn aiur_fn_240( + inp: [G; IN_240], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_240], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(170); + let __v_1: G = G::from_u64(87); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(195); + let __v_4: G = G::from_u64(244); + let __v_5: G = G::from_u64(249); + let __v_6: G = G::from_u64(225); + let __v_7: G = G::from_u64(207); + let __v_8: G = G::from_u64(107); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(160); + let __v_11: G = G::from_u64(56); + let __v_12: G = G::from_u64(172); + let __v_13: G = G::from_u64(21); + let __v_14: G = G::from_u64(129); + let __v_15: G = G::from_u64(152); + let __v_16: G = G::from_u64(195); + let __v_17: G = G::from_u64(175); + let __v_18: G = G::from_u64(75); + let __v_19: G = G::from_u64(40); + let __v_20: G = G::from_u64(214); + let __v_21: G = G::from_u64(28); + let __v_22: G = G::from_u64(234); + let __v_23: G = G::from_u64(121); + let __v_24: G = G::from_u64(149); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(92); + let __v_27: G = G::from_u64(167); + let __v_28: G = G::from_u64(199); + let __v_29: G = G::from_u64(184); + let __v_30: G = G::from_u64(44); + let __v_31: G = G::from_u64(41); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_240] = [__v_32]; + record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_241: usize = 0; +const IN_241: usize = 0; +const OUT_241: usize = 1; +fn aiur_fn_241( + inp: [G; IN_241], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_241], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(18); + let __v_1: G = G::from_u64(73); + let __v_2: G = G::from_u64(132); + let __v_3: G = G::from_u64(188); + let __v_4: G = G::from_u64(185); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(8); + let __v_7: G = G::from_u64(160); + let __v_8: G = G::from_u64(243); + let __v_9: G = G::from_u64(11); + let __v_10: G = G::from_u64(182); + let __v_11: G = G::from_u64(157); + let __v_12: G = G::from_u64(103); + let __v_13: G = G::from_u64(54); + let __v_14: G = G::from_u64(211); + let __v_15: G = G::from_u64(213); + let __v_16: G = G::from_u64(148); + let __v_17: G = G::from_u64(4); + let __v_18: G = G::from_u64(225); + let __v_19: G = G::from_u64(21); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(32); + let __v_23: G = G::from_u64(67); + let __v_24: G = G::from_u64(253); + let __v_25: G = G::from_u64(163); + let __v_26: G = G::from_u64(211); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(176); + let __v_30: G = G::from_u64(173); + let __v_31: G = G::from_u64(22); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_241] = [__v_32]; + record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_242: usize = 0; +const IN_242: usize = 0; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_242], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(51); + let __v_1: G = G::from_u64(217); + let __v_2: G = G::from_u64(74); + let __v_3: G = G::from_u64(45); + let __v_4: G = G::from_u64(37); + let __v_5: G = G::from_u64(10); + let __v_6: G = G::from_u64(26); + let __v_7: G = G::from_u64(90); + let __v_8: G = G::from_u64(160); + let __v_9: G = G::from_u64(34); + let __v_10: G = G::from_u64(227); + let __v_11: G = G::from_u64(190); + let __v_12: G = G::from_u64(253); + let __v_13: G = G::from_u64(202); + let __v_14: G = G::from_u64(28); + let __v_15: G = G::from_u64(134); + let __v_16: G = G::from_u64(244); + let __v_17: G = G::from_u64(93); + let __v_18: G = G::from_u64(112); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(29); + let __v_21: G = G::from_u64(176); + let __v_22: G = G::from_u64(56); + let __v_23: G = G::from_u64(239); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(184); + let __v_26: G = G::from_u64(152); + let __v_27: G = G::from_u64(13); + let __v_28: G = G::from_u64(197); + let __v_29: G = G::from_u64(22); + let __v_30: G = G::from_u64(11); + let __v_31: G = G::from_u64(118); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_242] = [__v_32]; + record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_243: usize = 0; +const IN_243: usize = 0; +const OUT_243: usize = 1; +fn aiur_fn_243( + inp: [G; IN_243], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_243], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(249); + let __v_1: G = G::from_u64(66); + let __v_2: G = G::from_u64(113); + let __v_3: G = G::from_u64(72); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(253); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(2); + let __v_9: G = G::from_u64(212); + let __v_10: G = G::from_u64(46); + let __v_11: G = G::from_u64(34); + let __v_12: G = G::from_u64(39); + let __v_13: G = G::from_u64(28); + let __v_14: G = G::from_u64(137); + let __v_15: G = G::from_u64(226); + let __v_16: G = G::from_u64(29); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(69); + let __v_19: G = G::from_u64(107); + let __v_20: G = G::from_u64(5); + let __v_21: G = G::from_u64(8); + let __v_22: G = G::from_u64(89); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(209); + let __v_25: G = G::from_u64(46); + let __v_26: G = G::from_u64(61); + let __v_27: G = G::from_u64(29); + let __v_28: G = G::from_u64(105); + let __v_29: G = G::from_u64(155); + let __v_30: G = G::from_u64(180); + let __v_31: G = G::from_u64(234); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_243] = [__v_32]; + record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_244: usize = 0; +const IN_244: usize = 0; +const OUT_244: usize = 1; +fn aiur_fn_244( + inp: [G; IN_244], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_244], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(42); + let __v_1: G = G::from_u64(203); + let __v_2: G = G::from_u64(137); + let __v_3: G = G::from_u64(66); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(88); + let __v_6: G = G::from_u64(125); + let __v_7: G = G::from_u64(10); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(241); + let __v_10: G = G::from_u64(121); + let __v_11: G = G::from_u64(93); + let __v_12: G = G::from_u64(249); + let __v_13: G = G::from_u64(4); + let __v_14: G = G::from_u64(38); + let __v_15: G = G::from_u64(234); + let __v_16: G = G::from_u64(255); + let __v_17: G = G::from_u64(84); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(243); + let __v_20: G = G::from_u64(204); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(137); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(209); + let __v_27: G = G::from_u64(71); + let __v_28: G = G::from_u64(22); + let __v_29: G = G::from_u64(167); + let __v_30: G = G::from_u64(143); + let __v_31: G = G::from_u64(173); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_244] = [__v_32]; + record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_245: usize = 0; +const IN_245: usize = 0; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_245], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(6); + let __v_1: G = G::from_u64(138); + let __v_2: G = G::from_u64(136); + let __v_3: G = G::from_u64(65); + let __v_4: G = G::from_u64(14); + let __v_5: G = G::from_u64(244); + let __v_6: G = G::from_u64(69); + let __v_7: G = G::from_u64(211); + let __v_8: G = G::from_u64(26); + let __v_9: G = G::from_u64(229); + let __v_10: G = G::from_u64(142); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(17); + let __v_13: G = G::from_u64(179); + let __v_14: G = G::from_u64(104); + let __v_15: G = G::from_u64(65); + let __v_16: G = G::from_u64(67); + let __v_17: G = G::from_u64(228); + let __v_18: G = G::from_u64(114); + let __v_19: G = G::from_u64(40); + let __v_20: G = G::from_u64(139); + let __v_21: G = G::from_u64(212); + let __v_22: G = G::from_u64(168); + let __v_23: G = G::from_u64(132); + let __v_24: G = G::from_u64(213); + let __v_25: G = G::from_u64(249); + let __v_26: G = G::from_u64(40); + let __v_27: G = G::from_u64(195); + let __v_28: G = G::from_u64(210); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(236); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_245] = [__v_32]; + record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_246: usize = 0; +const IN_246: usize = 0; +const OUT_246: usize = 1; +fn aiur_fn_246( + inp: [G; IN_246], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_246], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(244); + let __v_1: G = G::from_u64(205); + let __v_2: G = G::from_u64(188); + let __v_3: G = G::from_u64(94); + let __v_4: G = G::from_u64(217); + let __v_5: G = G::from_u64(161); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(89); + let __v_8: G = G::from_u64(40); + let __v_9: G = G::from_u64(249); + let __v_10: G = G::from_u64(147); + let __v_11: G = G::from_u64(31); + let __v_12: G = G::from_u64(92); + let __v_13: G = G::from_u64(35); + let __v_14: G = G::from_u64(144); + let __v_15: G = G::from_u64(35); + let __v_16: G = G::from_u64(158); + let __v_17: G = G::from_u64(127); + let __v_18: G = G::from_u64(71); + let __v_19: G = G::from_u64(223); + let __v_20: G = G::from_u64(109); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(232); + let __v_23: G = G::from_u64(78); + let __v_24: G = G::from_u64(164); + let __v_25: G = G::from_u64(101); + let __v_26: G = G::from_u64(201); + let __v_27: G = G::from_u64(112); + let __v_28: G = G::from_u64(123); + let __v_29: G = G::from_u64(132); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(193); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_246] = [__v_32]; + record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_247: usize = 0; +const IN_247: usize = 0; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_247], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(113); + let __v_3: G = G::from_u64(188); + let __v_4: G = G::from_u64(223); + let __v_5: G = G::from_u64(178); + let __v_6: G = G::from_u64(231); + let __v_7: G = G::from_u64(105); + let __v_8: G = G::from_u64(225); + let __v_9: G = G::from_u64(172); + let __v_10: G = G::from_u64(160); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(122); + let __v_13: G = G::from_u64(59); + let __v_14: G = G::from_u64(58); + let __v_15: G = G::from_u64(33); + let __v_16: G = G::from_u64(168); + let __v_17: G = G::from_u64(217); + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(204); + let __v_20: G = G::from_u64(39); + let __v_21: G = G::from_u64(55); + let __v_22: G = G::from_u64(7); + let __v_23: G = G::from_u64(200); + let __v_24: G = G::from_u64(146); + let __v_25: G = G::from_u64(235); + let __v_26: G = G::from_u64(134); + let __v_27: G = G::from_u64(123); + let __v_28: G = G::from_u64(127); + let __v_29: G = G::from_u64(199); + let __v_30: G = G::from_u64(138); + let __v_31: G = G::from_u64(226); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_247] = [__v_32]; + record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_248: usize = 0; +const IN_248: usize = 0; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_248], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(100); + let __v_1: G = G::from_u64(5); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(85); + let __v_4: G = G::from_u64(186); + let __v_5: G = G::from_u64(112); + let __v_6: G = G::from_u64(194); + let __v_7: G = G::from_u64(178); + let __v_8: G = G::from_u64(23); + let __v_9: G = G::from_u64(156); + let __v_10: G = G::from_u64(121); + let __v_11: G = G::from_u64(102); + let __v_12: G = G::from_u64(198); + let __v_13: G = G::from_u64(246); + let __v_14: G = G::from_u64(16); + let __v_15: G = G::from_u64(191); + let __v_16: G = G::from_u64(52); + let __v_17: G = G::from_u64(23); + let __v_18: G = G::from_u64(189); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(61); + let __v_21: G = G::from_u64(210); + let __v_22: G = G::from_u64(186); + let __v_23: G = G::from_u64(122); + let __v_24: G = G::from_u64(82); + let __v_25: G = G::from_u64(37); + let __v_26: G = G::from_u64(51); + let __v_27: G = G::from_u64(194); + let __v_28: G = G::from_u64(205); + let __v_29: G = G::from_u64(158); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(11); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_248] = [__v_32]; + record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_249: usize = 0; +const IN_249: usize = 0; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: [G; IN_249], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_249], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(156); + let __v_1: G = G::from_u64(10); + let __v_2: G = G::from_u64(242); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(147); + let __v_5: G = G::from_u64(203); + let __v_6: G = G::from_u64(92); + let __v_7: G = G::from_u64(8); + let __v_8: G = G::from_u64(53); + let __v_9: G = G::from_u64(228); + let __v_10: G = G::from_u64(78); + let __v_11: G = G::from_u64(96); + let __v_12: G = G::from_u64(228); + let __v_13: G = G::from_u64(195); + let __v_14: G = G::from_u64(230); + let __v_15: G = G::from_u64(142); + let __v_16: G = G::from_u64(235); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(111); + let __v_19: G = G::from_u64(209); + let __v_20: G = G::from_u64(106); + let __v_21: G = G::from_u64(255); + let __v_22: G = G::from_u64(173); + let __v_23: G = G::from_u64(50); + let __v_24: G = G::from_u64(22); + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(106); + let __v_27: G = G::from_u64(53); + let __v_28: G = G::from_u64(254); + let __v_29: G = G::from_u64(145); + let __v_30: G = G::from_u64(185); + let __v_31: G = G::from_u64(193); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_249] = [__v_32]; + record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_250: usize = 0; +const IN_250: usize = 0; +const OUT_250: usize = 1; +fn aiur_fn_250( + inp: [G; IN_250], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_250], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(30); + let __v_1: G = G::from_u64(37); + let __v_2: G = G::from_u64(17); + let __v_3: G = G::from_u64(152); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(6); + let __v_6: G = G::from_u64(37); + let __v_7: G = G::from_u64(98); + let __v_8: G = G::from_u64(142); + let __v_9: G = G::from_u64(46); + let __v_10: G = G::from_u64(176); + let __v_11: G = G::from_u64(152); + let __v_12: G = G::from_u64(63); + let __v_13: G = G::from_u64(123); + let __v_14: G = G::from_u64(233); + let __v_15: G = G::from_u64(239); + let __v_16: G = G::from_u64(232); + let __v_17: G = G::from_u64(215); + let __v_18: G = G::from_u64(25); + let __v_19: G = G::from_u64(161); + let __v_20: G = G::from_u64(4); + let __v_21: G = G::from_u64(168); + let __v_22: G = G::from_u64(97); + let __v_23: G = G::from_u64(242); + let __v_24: G = G::from_u64(190); + let __v_25: G = G::from_u64(242); + let __v_26: G = G::from_u64(244); + let __v_27: G = G::from_u64(126); + let __v_28: G = G::from_u64(171); + let __v_29: G = G::from_u64(238); + let __v_30: G = G::from_u64(212); + let __v_31: G = G::from_u64(249); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_250] = [__v_32]; + record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_251: usize = 0; +const IN_251: usize = 0; +const OUT_251: usize = 1; +fn aiur_fn_251( + inp: [G; IN_251], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_251], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(226); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(41); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(26); + let __v_5: G = G::from_u64(223); + let __v_6: G = G::from_u64(84); + let __v_7: G = G::from_u64(176); + let __v_8: G = G::from_u64(211); + let __v_9: G = G::from_u64(147); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(132); + let __v_12: G = G::from_u64(119); + let __v_13: G = G::from_u64(24); + let __v_14: G = G::from_u64(220); + let __v_15: G = G::from_u64(137); + let __v_16: G = G::from_u64(166); + let __v_17: G = G::from_u64(51); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(232); + let __v_20: G = G::from_u64(243); + let __v_21: G = G::from_u64(27); + let __v_22: G = G::from_u64(65); + let __v_23: G = G::from_u64(201); + let __v_24: G = G::from_u64(232); + let __v_25: G = G::from_u64(15); + let __v_26: G = G::from_u64(140); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(32); + let __v_29: G = G::from_u64(23); + let __v_30: G = G::from_u64(39); + let __v_31: G = G::from_u64(141); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_251] = [__v_32]; + record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_252: usize = 0; +const IN_252: usize = 0; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: [G; IN_252], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_252], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(134); + let __v_1: G = G::from_u64(41); + let __v_2: G = G::from_u64(81); + let __v_3: G = G::from_u64(150); + let __v_4: G = G::from_u64(50); + let __v_5: G = G::from_u64(225); + let __v_6: G = G::from_u64(140); + let __v_7: G = G::from_u64(73); + let __v_8: G = G::from_u64(9); + let __v_9: G = G::from_u64(121); + let __v_10: G = G::from_u64(54); + let __v_11: G = G::from_u64(252); + let __v_12: G = G::from_u64(34); + let __v_13: G = G::from_u64(12); + let __v_14: G = G::from_u64(158); + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(214); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(63); + let __v_19: G = G::from_u64(221); + let __v_20: G = G::from_u64(235); + let __v_21: G = G::from_u64(164); + let __v_22: G = G::from_u64(70); + let __v_23: G = G::from_u64(42); + let __v_24: G = G::from_u64(245); + let __v_25: G = G::from_u64(183); + let __v_26: G = G::from_u64(23); + let __v_27: G = G::from_u64(221); + let __v_28: G = G::from_u64(17); + let __v_29: G = G::from_u64(228); + let __v_30: G = G::from_u64(190); + let __v_31: G = G::from_u64(244); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_252] = [__v_32]; + record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_253: usize = 0; +const IN_253: usize = 0; +const OUT_253: usize = 1; +fn aiur_fn_253( + inp: [G; IN_253], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_253], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(149); + let __v_2: G = G::from_u64(192); + let __v_3: G = G::from_u64(113); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(72); + let __v_6: G = G::from_u64(90); + let __v_7: G = G::from_u64(242); + let __v_8: G = G::from_u64(217); + let __v_9: G = G::from_u64(152); + let __v_10: G = G::from_u64(227); + let __v_11: G = G::from_u64(148); + let __v_12: G = G::from_u64(123); + let __v_13: G = G::from_u64(229); + let __v_14: G = G::from_u64(152); + let __v_15: G = G::from_u64(128); + let __v_16: G = G::from_u64(119); + let __v_17: G = G::from_u64(83); + let __v_18: G = G::from_u64(31); + let __v_19: G = G::from_u64(2); + let __v_20: G = G::from_u64(191); + let __v_21: G = G::from_u64(9); + let __v_22: G = G::from_u64(27); + let __v_23: G = G::from_u64(135); + let __v_24: G = G::from_u64(13); + let __v_25: G = G::from_u64(83); + let __v_26: G = G::from_u64(206); + let __v_27: G = G::from_u64(88); + let __v_28: G = G::from_u64(157); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(245); + let __v_31: G = G::from_u64(177); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_253] = [__v_32]; + record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_254: usize = 0; +const IN_254: usize = 0; +const OUT_254: usize = 1; +fn aiur_fn_254( + inp: [G; IN_254], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_254], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(25); + let __v_1: G = G::from_u64(224); + let __v_2: G = G::from_u64(27); + let __v_3: G = G::from_u64(201); + let __v_4: G = G::from_u64(163); + let __v_5: G = G::from_u64(38); + let __v_6: G = G::from_u64(75); + let __v_7: G = G::from_u64(155); + let __v_8: G = G::from_u64(139); + let __v_9: G = G::from_u64(148); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(241); + let __v_12: G = G::from_u64(114); + let __v_13: G = G::from_u64(162); + let __v_14: G = G::from_u64(9); + let __v_15: G = G::from_u64(187); + let __v_16: G = G::from_u64(119); + let __v_17: G = G::from_u64(74); + let __v_18: G = G::from_u64(211); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(100); + let __v_21: G = G::from_u64(16); + let __v_22: G = G::from_u64(250); + let __v_23: G = G::from_u64(116); + let __v_24: G = G::from_u64(47); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(72); + let __v_27: G = G::from_u64(4); + let __v_28: G = G::from_u64(104); + let __v_29: G = G::from_u64(8); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(182); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_254] = [__v_32]; + record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_255: usize = 0; +const IN_255: usize = 0; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_255], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(126); + let __v_1: G = G::from_u64(4); + let __v_2: G = G::from_u64(142); + let __v_3: G = G::from_u64(243); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(236); + let __v_6: G = G::from_u64(220); + let __v_7: G = G::from_u64(131); + let __v_8: G = G::from_u64(100); + let __v_9: G = G::from_u64(103); + let __v_10: G = G::from_u64(205); + let __v_11: G = G::from_u64(212); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(146); + let __v_14: G = G::from_u64(247); + let __v_15: G = G::from_u64(254); + let __v_16: G = G::from_u64(38); + let __v_17: G = G::from_u64(251); + let __v_18: G = G::from_u64(189); + let __v_19: G = G::from_u64(123); + let __v_20: G = G::from_u64(98); + let __v_21: G = G::from_u64(174); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(23); + let __v_24: G = G::from_u64(70); + let __v_25: G = G::from_u64(84); + let __v_26: G = G::from_u64(63); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(48); + let __v_29: G = G::from_u64(152); + let __v_30: G = G::from_u64(198); + let __v_31: G = G::from_u64(225); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_255] = [__v_32]; + record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_256: usize = 0; +const IN_256: usize = 0; +const OUT_256: usize = 1; +fn aiur_fn_256( + inp: [G; IN_256], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_256], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(108); + let __v_1: G = G::from_u64(194); + let __v_2: G = G::from_u64(214); + let __v_3: G = G::from_u64(61); + let __v_4: G = G::from_u64(161); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(83); + let __v_9: G = G::from_u64(63); + let __v_10: G = G::from_u64(203); + let __v_11: G = G::from_u64(8); + let __v_12: G = G::from_u64(203); + let __v_13: G = G::from_u64(179); + let __v_14: G = G::from_u64(140); + let __v_15: G = G::from_u64(45); + let __v_16: G = G::from_u64(103); + let __v_17: G = G::from_u64(247); + let __v_18: G = G::from_u64(81); + let __v_19: G = G::from_u64(42); + let __v_20: G = G::from_u64(126); + let __v_21: G = G::from_u64(253); + let __v_22: G = G::from_u64(21); + let __v_23: G = G::from_u64(35); + let __v_24: G = G::from_u64(106); + let __v_25: G = G::from_u64(75); + let __v_26: G = G::from_u64(14); + let __v_27: G = G::from_u64(87); + let __v_28: G = G::from_u64(187); + let __v_29: G = G::from_u64(31); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(83); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_256] = [__v_32]; + record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_257: usize = 0; +const IN_257: usize = 0; +const OUT_257: usize = 1; +fn aiur_fn_257( + inp: [G; IN_257], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_257], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(70); + let __v_1: G = G::from_u64(181); + let __v_2: G = G::from_u64(235); + let __v_3: G = G::from_u64(103); + let __v_4: G = G::from_u64(104); + let __v_5: G = G::from_u64(193); + let __v_6: G = G::from_u64(244); + let __v_7: G = G::from_u64(149); + let __v_8: G = G::from_u64(135); + let __v_9: G = G::from_u64(214); + let __v_10: G = G::from_u64(83); + let __v_11: G = G::from_u64(193); + let __v_12: G = G::from_u64(46); + let __v_13: G = G::from_u64(55); + let __v_14: G = G::from_u64(51); + let __v_15: G = G::from_u64(137); + let __v_16: G = G::from_u64(18); + let __v_17: G = G::from_u64(21); + let __v_18: G = G::from_u64(51); + let __v_19: G = G::from_u64(134); + let __v_20: G = G::from_u64(131); + let __v_21: G = G::from_u64(47); + let __v_22: G = G::from_u64(15); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(228); + let __v_25: G = G::from_u64(114); + let __v_26: G = G::from_u64(72); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(38); + let __v_29: G = G::from_u64(50); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(50); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_257] = [__v_32]; + record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_258: usize = 0; +const IN_258: usize = 0; +const OUT_258: usize = 1; +fn aiur_fn_258( + inp: [G; IN_258], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_258], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(37); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(205); + let __v_3: G = G::from_u64(117); + let __v_4: G = G::from_u64(107); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(235); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(188); + let __v_9: G = G::from_u64(225); + let __v_10: G = G::from_u64(112); + let __v_11: G = G::from_u64(65); + let __v_12: G = G::from_u64(13); + let __v_13: G = G::from_u64(239); + let __v_14: G = G::from_u64(164); + let __v_15: G = G::from_u64(193); + let __v_16: G = G::from_u64(91); + let __v_17: G = G::from_u64(35); + let __v_18: G = G::from_u64(141); + let __v_19: G = G::from_u64(237); + let __v_20: G = G::from_u64(239); + let __v_21: G = G::from_u64(95); + let __v_22: G = G::from_u64(123); + let __v_23: G = G::from_u64(137); + let __v_24: G = G::from_u64(105); + let __v_25: G = G::from_u64(22); + let __v_26: G = G::from_u64(33); + let __v_27: G = G::from_u64(220); + let __v_28: G = G::from_u64(190); + let __v_29: G = G::from_u64(145); + let __v_30: G = G::from_u64(151); + let __v_31: G = G::from_u64(128); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_258] = [__v_32]; + record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_259: usize = 0; +const IN_259: usize = 0; +const OUT_259: usize = 1; +fn aiur_fn_259( + inp: [G; IN_259], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_259], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(39); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(169); + let __v_3: G = G::from_u64(225); + let __v_4: G = G::from_u64(108); + let __v_5: G = G::from_u64(3); + let __v_6: G = G::from_u64(233); + let __v_7: G = G::from_u64(173); + let __v_8: G = G::from_u64(115); + let __v_9: G = G::from_u64(55); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(6); + let __v_12: G = G::from_u64(215); + let __v_13: G = G::from_u64(62); + let __v_14: G = G::from_u64(253); + let __v_15: G = G::from_u64(20); + let __v_16: G = G::from_u64(204); + let __v_17: G = G::from_u64(241); + let __v_18: G = G::from_u64(218); + let __v_19: G = G::from_u64(16); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(248); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(125); + let __v_24: G = G::from_u64(211); + let __v_25: G = G::from_u64(67); + let __v_26: G = G::from_u64(116); + let __v_27: G = G::from_u64(182); + let __v_28: G = G::from_u64(14); + let __v_29: G = G::from_u64(21); + let __v_30: G = G::from_u64(86); + let __v_31: G = G::from_u64(250); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_259] = [__v_32]; + record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_260: usize = 0; +const IN_260: usize = 0; +const OUT_260: usize = 1; +fn aiur_fn_260( + inp: [G; IN_260], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_260], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(122); + let __v_1: G = G::from_u64(24); + let __v_2: G = G::from_u64(202); + let __v_3: G = G::from_u64(132); + let __v_4: G = G::from_u64(161); + let __v_5: G = G::from_u64(19); + let __v_6: G = G::from_u64(176); + let __v_7: G = G::from_u64(194); + let __v_8: G = G::from_u64(173); + let __v_9: G = G::from_u64(12); + let __v_10: G = G::from_u64(192); + let __v_11: G = G::from_u64(232); + let __v_12: G = G::from_u64(37); + let __v_13: G = G::from_u64(165); + let __v_14: G = G::from_u64(93); + let __v_15: G = G::from_u64(118); + let __v_16: G = G::from_u64(126); + let __v_17: G = G::from_u64(119); + let __v_18: G = G::from_u64(168); + let __v_19: G = G::from_u64(158); + let __v_20: G = G::from_u64(141); + let __v_21: G = G::from_u64(14); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(130); + let __v_24: G = G::from_u64(235); + let __v_25: G = G::from_u64(145); + let __v_26: G = G::from_u64(4); + let __v_27: G = G::from_u64(133); + let __v_28: G = G::from_u64(159); + let __v_29: G = G::from_u64(83); + let __v_30: G = G::from_u64(208); + let __v_31: G = G::from_u64(149); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_260] = [__v_32]; + record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_261: usize = 0; +const IN_261: usize = 0; +const OUT_261: usize = 1; +fn aiur_fn_261( + inp: [G; IN_261], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_261], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(58); + let __v_1: G = G::from_u64(226); + let __v_2: G = G::from_u64(199); + let __v_3: G = G::from_u64(29); + let __v_4: G = G::from_u64(162); + let __v_5: G = G::from_u64(191); + let __v_6: G = G::from_u64(52); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(154); + let __v_9: G = G::from_u64(90); + let __v_10: G = G::from_u64(136); + let __v_11: G = G::from_u64(8); + let __v_12: G = G::from_u64(133); + let __v_13: G = G::from_u64(124); + let __v_14: G = G::from_u64(52); + let __v_15: G = G::from_u64(163); + let __v_16: G = G::from_u64(183); + let __v_17: G = G::from_u64(102); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(245); + let __v_20: G = G::from_u64(101); + let __v_21: G = G::from_u64(77); + let __v_22: G = G::from_u64(140); + let __v_23: G = G::from_u64(36); + let __v_24: G = G::from_u64(124); + let __v_25: G = G::from_u64(67); + let __v_26: G = G::from_u64(232); + let __v_27: G = G::from_u64(90); + let __v_28: G = G::from_u64(124); + let __v_29: G = G::from_u64(222); + let __v_30: G = G::from_u64(73); + let __v_31: G = G::from_u64(63); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_261] = [__v_32]; + record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_262: usize = 0; +const IN_262: usize = 0; +const OUT_262: usize = 1; +fn aiur_fn_262( + inp: [G; IN_262], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_262], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(16); + let __v_1: G = G::from_u64(172); + let __v_2: G = G::from_u64(95); + let __v_3: G = G::from_u64(72); + let __v_4: G = G::from_u64(121); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(63); + let __v_7: G = G::from_u64(240); + let __v_8: G = G::from_u64(27); + let __v_9: G = G::from_u64(15); + let __v_10: G = G::from_u64(116); + let __v_11: G = G::from_u64(192); + let __v_12: G = G::from_u64(181); + let __v_13: G = G::from_u64(68); + let __v_14: G = G::from_u64(210); + let __v_15: G = G::from_u64(39); + let __v_16: G = G::from_u64(150); + let __v_17: G = G::from_u64(201); + let __v_18: G = G::from_u64(119); + let __v_19: G = G::from_u64(95); + let __v_20: G = G::from_u64(109); + let __v_21: G = G::from_u64(67); + let __v_22: G = G::from_u64(211); + let __v_23: G = G::from_u64(40); + let __v_24: G = G::from_u64(49); + let __v_25: G = G::from_u64(107); + let __v_26: G = G::from_u64(187); + let __v_27: G = G::from_u64(58); + let __v_28: G = G::from_u64(161); + let __v_29: G = G::from_u64(99); + let __v_30: G = G::from_u64(137); + let __v_31: G = G::from_u64(153); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_262] = [__v_32]; + record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_263: usize = 0; +const IN_263: usize = 0; +const OUT_263: usize = 1; +fn aiur_fn_263( + inp: [G; IN_263], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_263], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(186); + let __v_1: G = G::from_u64(179); + let __v_2: G = G::from_u64(122); + let __v_3: G = G::from_u64(139); + let __v_4: G = G::from_u64(217); + let __v_5: G = G::from_u64(134); + let __v_6: G = G::from_u64(13); + let __v_7: G = G::from_u64(59); + let __v_8: G = G::from_u64(254); + let __v_9: G = G::from_u64(49); + let __v_10: G = G::from_u64(241); + let __v_11: G = G::from_u64(161); + let __v_12: G = G::from_u64(117); + let __v_13: G = G::from_u64(47); + let __v_14: G = G::from_u64(231); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(138); + let __v_17: G = G::from_u64(34); + let __v_18: G = G::from_u64(76); + let __v_19: G = G::from_u64(106); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(175); + let __v_22: G = G::from_u64(98); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(127); + let __v_25: G = G::from_u64(184); + let __v_26: G = G::from_u64(189); + let __v_27: G = G::from_u64(25); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(229); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(126); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_263] = [__v_32]; + record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_264: usize = 0; +const IN_264: usize = 0; +const OUT_264: usize = 1; +fn aiur_fn_264( + inp: [G; IN_264], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_264], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(152); + let __v_1: G = G::from_u64(27); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(183); + let __v_4: G = G::from_u64(196); + let __v_5: G = G::from_u64(88); + let __v_6: G = G::from_u64(153); + let __v_7: G = G::from_u64(247); + let __v_8: G = G::from_u64(38); + let __v_9: G = G::from_u64(195); + let __v_10: G = G::from_u64(222); + let __v_11: G = G::from_u64(53); + let __v_12: G = G::from_u64(50); + let __v_13: G = G::from_u64(128); + let __v_14: G = G::from_u64(116); + let __v_15: G = G::from_u64(203); + let __v_16: G = G::from_u64(63); + let __v_17: G = G::from_u64(114); + let __v_18: G = G::from_u64(160); + let __v_19: G = G::from_u64(146); + let __v_20: G = G::from_u64(37); + let __v_21: G = G::from_u64(116); + let __v_22: G = G::from_u64(61); + let __v_23: G = G::from_u64(168); + let __v_24: G = G::from_u64(31); + let __v_25: G = G::from_u64(80); + let __v_26: G = G::from_u64(49); + let __v_27: G = G::from_u64(255); + let __v_28: G = G::from_u64(110); + let __v_29: G = G::from_u64(100); + let __v_30: G = G::from_u64(123); + let __v_31: G = G::from_u64(169); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_264] = [__v_32]; + record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_265: usize = 0; +const IN_265: usize = 0; +const OUT_265: usize = 1; +fn aiur_fn_265( + inp: [G; IN_265], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_265], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(165); + let __v_1: G = G::from_u64(123); + let __v_2: G = G::from_u64(129); + let __v_3: G = G::from_u64(128); + let __v_4: G = G::from_u64(40); + let __v_5: G = G::from_u64(135); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(206); + let __v_8: G = G::from_u64(191); + let __v_9: G = G::from_u64(177); + let __v_10: G = G::from_u64(214); + let __v_11: G = G::from_u64(221); + let __v_12: G = G::from_u64(41); + let __v_13: G = G::from_u64(241); + let __v_14: G = G::from_u64(96); + let __v_15: G = G::from_u64(204); + let __v_16: G = G::from_u64(74); + let __v_17: G = G::from_u64(204); + let __v_18: G = G::from_u64(60); + let __v_19: G = G::from_u64(106); + let __v_20: G = G::from_u64(186); + let __v_21: G = G::from_u64(152); + let __v_22: G = G::from_u64(52); + let __v_23: G = G::from_u64(228); + let __v_24: G = G::from_u64(107); + let __v_25: G = G::from_u64(101); + let __v_26: G = G::from_u64(241); + let __v_27: G = G::from_u64(197); + let __v_28: G = G::from_u64(170); + let __v_29: G = G::from_u64(114); + let __v_30: G = G::from_u64(23); + let __v_31: G = G::from_u64(226); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_265] = [__v_32]; + record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_266: usize = 0; +const IN_266: usize = 0; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_266], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(155); + let __v_2: G = G::from_u64(60); + let __v_3: G = G::from_u64(28); + let __v_4: G = G::from_u64(165); + let __v_5: G = G::from_u64(217); + let __v_6: G = G::from_u64(240); + let __v_7: G = G::from_u64(155); + let __v_8: G = G::from_u64(144); + let __v_9: G = G::from_u64(35); + let __v_10: G = G::from_u64(33); + let __v_11: G = G::from_u64(177); + let __v_12: G = G::from_u64(85); + let __v_13: G = G::from_u64(237); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(82); + let __v_16: G = G::from_u64(76); + let __v_17: G = G::from_u64(62); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(222); + let __v_20: G = G::from_u64(29); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(13); + let __v_23: G = G::from_u64(185); + let __v_24: G = G::from_u64(23); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(186); + let __v_27: G = G::from_u64(170); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(63); + let __v_30: G = G::from_u64(143); + let __v_31: G = G::from_u64(130); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_266] = [__v_32]; + record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_267: usize = 0; +const IN_267: usize = 0; +const OUT_267: usize = 1; +fn aiur_fn_267( + inp: [G; IN_267], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_267], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(69); + let __v_2: G = G::from_u64(58); + let __v_3: G = G::from_u64(124); + let __v_4: G = G::from_u64(237); + let __v_5: G = G::from_u64(175); + let __v_6: G = G::from_u64(226); + let __v_7: G = G::from_u64(237); + let __v_8: G = G::from_u64(187); + let __v_9: G = G::from_u64(193); + let __v_10: G = G::from_u64(240); + let __v_11: G = G::from_u64(80); + let __v_12: G = G::from_u64(52); + let __v_13: G = G::from_u64(66); + let __v_14: G = G::from_u64(190); + let __v_15: G = G::from_u64(73); + let __v_16: G = G::from_u64(158); + let __v_17: G = G::from_u64(76); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(24); + let __v_20: G = G::from_u64(166); + let __v_21: G = G::from_u64(192); + let __v_22: G = G::from_u64(13); + let __v_23: G = G::from_u64(201); + let __v_24: G = G::from_u64(159); + let __v_25: G = G::from_u64(57); + let __v_26: G = G::from_u64(3); + let __v_27: G = G::from_u64(238); + let __v_28: G = G::from_u64(127); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(219); + let __v_31: G = G::from_u64(175); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_267] = [__v_32]; + record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_268: usize = 0; +const IN_268: usize = 0; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_268], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(84); + let __v_1: G = G::from_u64(25); + let __v_2: G = G::from_u64(24); + let __v_3: G = G::from_u64(127); + let __v_4: G = G::from_u64(191); + let __v_5: G = G::from_u64(103); + let __v_6: G = G::from_u64(239); + let __v_7: G = G::from_u64(28); + let __v_8: G = G::from_u64(79); + let __v_9: G = G::from_u64(249); + let __v_10: G = G::from_u64(171); + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(225); + let __v_13: G = G::from_u64(176); + let __v_14: G = G::from_u64(29); + let __v_15: G = G::from_u64(70); + let __v_16: G = G::from_u64(49); + let __v_17: G = G::from_u64(162); + let __v_18: G = G::from_u64(112); + let __v_19: G = G::from_u64(100); + let __v_20: G = G::from_u64(127); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(67); + let __v_23: G = G::from_u64(75); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(225); + let __v_26: G = G::from_u64(247); + let __v_27: G = G::from_u64(136); + let __v_28: G = G::from_u64(179); + let __v_29: G = G::from_u64(200); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(212); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_268] = [__v_32]; + record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_269: usize = 0; +const IN_269: usize = 0; +const OUT_269: usize = 1; +fn aiur_fn_269( + inp: [G; IN_269], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_269], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(212); + let __v_1: G = G::from_u64(131); + let __v_2: G = G::from_u64(150); + let __v_3: G = G::from_u64(100); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(173); + let __v_6: G = G::from_u64(71); + let __v_7: G = G::from_u64(206); + let __v_8: G = G::from_u64(65); + let __v_9: G = G::from_u64(85); + let __v_10: G = G::from_u64(179); + let __v_11: G = G::from_u64(72); + let __v_12: G = G::from_u64(88); + let __v_13: G = G::from_u64(25); + let __v_14: G = G::from_u64(163); + let __v_15: G = G::from_u64(119); + let __v_16: G = G::from_u64(226); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(5); + let __v_19: G = G::from_u64(181); + let __v_20: G = G::from_u64(154); + let __v_21: G = G::from_u64(26); + let __v_22: G = G::from_u64(175); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(182); + let __v_25: G = G::from_u64(129); + let __v_26: G = G::from_u64(203); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(168); + let __v_30: G = G::from_u64(49); + let __v_31: G = G::from_u64(7); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_269] = [__v_32]; + record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_270: usize = 0; +const IN_270: usize = 0; +const OUT_270: usize = 1; +fn aiur_fn_270( + inp: [G; IN_270], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_270], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(68); + let __v_2: G = G::from_u64(201); + let __v_3: G = G::from_u64(4); + let __v_4: G = G::from_u64(73); + let __v_5: G = G::from_u64(250); + let __v_6: G = G::from_u64(248); + let __v_7: G = G::from_u64(111); + let __v_8: G = G::from_u64(99); + let __v_9: G = G::from_u64(193); + let __v_10: G = G::from_u64(112); + let __v_11: G = G::from_u64(240); + let __v_12: G = G::from_u64(146); + let __v_13: G = G::from_u64(226); + let __v_14: G = G::from_u64(36); + let __v_15: G = G::from_u64(155); + let __v_16: G = G::from_u64(204); + let __v_17: G = G::from_u64(171); + let __v_18: G = G::from_u64(30); + let __v_19: G = G::from_u64(116); + let __v_20: G = G::from_u64(28); + let __v_21: G = G::from_u64(31); + let __v_22: G = G::from_u64(225); + let __v_23: G = G::from_u64(13); + let __v_24: G = G::from_u64(248); + let __v_25: G = G::from_u64(76); + let __v_26: G = G::from_u64(149); + let __v_27: G = G::from_u64(180); + let __v_28: G = G::from_u64(75); + let __v_29: G = G::from_u64(56); + let __v_30: G = G::from_u64(67); + let __v_31: G = G::from_u64(113); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_270] = [__v_32]; + record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_271: usize = 0; +const IN_271: usize = 0; +const OUT_271: usize = 1; +fn aiur_fn_271( + inp: [G; IN_271], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_271], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(88); + let __v_2: G = G::from_u64(195); + let __v_3: G = G::from_u64(101); + let __v_4: G = G::from_u64(96); + let __v_5: G = G::from_u64(68); + let __v_6: G = G::from_u64(215); + let __v_7: G = G::from_u64(250); + let __v_8: G = G::from_u64(239); + let __v_9: G = G::from_u64(105); + let __v_10: G = G::from_u64(118); + let __v_11: G = G::from_u64(55); + let __v_12: G = G::from_u64(245); + let __v_13: G = G::from_u64(22); + let __v_14: G = G::from_u64(215); + let __v_15: G = G::from_u64(38); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(211); + let __v_18: G = G::from_u64(91); + let __v_19: G = G::from_u64(24); + let __v_20: G = G::from_u64(102); + let __v_21: G = G::from_u64(60); + let __v_22: G = G::from_u64(178); + let __v_23: G = G::from_u64(99); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(204); + let __v_26: G = G::from_u64(202); + let __v_27: G = G::from_u64(140); + let __v_28: G = G::from_u64(221); + let __v_29: G = G::from_u64(46); + let __v_30: G = G::from_u64(111); + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_271] = [__v_32]; + record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_272: usize = 0; +const IN_272: usize = 0; +const OUT_272: usize = 1; +fn aiur_fn_272( + inp: [G; IN_272], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_272], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(72); + let __v_1: G = G::from_u64(145); + let __v_2: G = G::from_u64(135); + let __v_3: G = G::from_u64(233); + let __v_4: G = G::from_u64(205); + let __v_5: G = G::from_u64(3); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(235); + let __v_8: G = G::from_u64(193); + let __v_9: G = G::from_u64(42); + let __v_10: G = G::from_u64(19); + let __v_11: G = G::from_u64(53); + let __v_12: G = G::from_u64(198); + let __v_13: G = G::from_u64(40); + let __v_14: G = G::from_u64(214); + let __v_15: G = G::from_u64(66); + let __v_16: G = G::from_u64(234); + let __v_17: G = G::from_u64(42); + let __v_18: G = G::from_u64(72); + let __v_19: G = G::from_u64(189); + let __v_20: G = G::from_u64(194); + let __v_21: G = G::from_u64(98); + let __v_22: G = G::from_u64(200); + let __v_23: G = G::from_u64(95); + let __v_24: G = G::from_u64(132); + let __v_25: G = G::from_u64(143); + let __v_26: G = G::from_u64(16); + let __v_27: G = G::from_u64(17); + let __v_28: G = G::from_u64(231); + let __v_29: G = G::from_u64(63); + let __v_30: G = G::from_u64(97); + let __v_31: G = G::from_u64(10); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_272] = [__v_32]; + record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_273: usize = 0; +const IN_273: usize = 0; +const OUT_273: usize = 1; +fn aiur_fn_273( + inp: [G; IN_273], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_273], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(113); + let __v_1: G = G::from_u64(5); + let __v_2: G = G::from_u64(234); + let __v_3: G = G::from_u64(244); + let __v_4: G = G::from_u64(197); + let __v_5: G = G::from_u64(44); + let __v_6: G = G::from_u64(227); + let __v_7: G = G::from_u64(161); + let __v_8: G = G::from_u64(147); + let __v_9: G = G::from_u64(114); + let __v_10: G = G::from_u64(168); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(172); + let __v_13: G = G::from_u64(87); + let __v_14: G = G::from_u64(168); + let __v_15: G = G::from_u64(249); + let __v_16: G = G::from_u64(89); + let __v_17: G = G::from_u64(138); + let __v_18: G = G::from_u64(36); + let __v_19: G = G::from_u64(99); + let __v_20: G = G::from_u64(52); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(110); + let __v_23: G = G::from_u64(255); + let __v_24: G = G::from_u64(174); + let __v_25: G = G::from_u64(227); + let __v_26: G = G::from_u64(228); + let __v_27: G = G::from_u64(142); + let __v_28: G = G::from_u64(126); + let __v_29: G = G::from_u64(109); + let __v_30: G = G::from_u64(58); + let __v_31: G = G::from_u64(173); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_273] = [__v_32]; + record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_274: usize = 0; +const IN_274: usize = 0; +const OUT_274: usize = 1; +fn aiur_fn_274( + inp: [G; IN_274], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_274], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(162); + let __v_2: G = G::from_u64(220); + let __v_3: G = G::from_u64(118); + let __v_4: G = G::from_u64(162); + let __v_5: G = G::from_u64(207); + let __v_6: G = G::from_u64(204); + let __v_7: G = G::from_u64(148); + let __v_8: G = G::from_u64(64); + let __v_9: G = G::from_u64(244); + let __v_10: G = G::from_u64(67); + let __v_11: G = G::from_u64(198); + let __v_12: G = G::from_u64(102); + let __v_13: G = G::from_u64(83); + let __v_14: G = G::from_u64(111); + let __v_15: G = G::from_u64(47); + let __v_16: G = G::from_u64(169); + let __v_17: G = G::from_u64(156); + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(80); + let __v_20: G = G::from_u64(182); + let __v_21: G = G::from_u64(66); + let __v_22: G = G::from_u64(253); + let __v_23: G = G::from_u64(57); + let __v_24: G = G::from_u64(113); + let __v_25: G = G::from_u64(251); + let __v_26: G = G::from_u64(173); + let __v_27: G = G::from_u64(37); + let __v_28: G = G::from_u64(213); + let __v_29: G = G::from_u64(49); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(42); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_274] = [__v_32]; + record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_275: usize = 0; +const IN_275: usize = 0; +const OUT_275: usize = 1; +fn aiur_fn_275( + inp: [G; IN_275], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_275], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(33); + let __v_1: G = G::from_u64(27); + let __v_2: G = G::from_u64(245); + let __v_3: G = G::from_u64(237); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(76); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(212); + let __v_8: G = G::from_u64(87); + let __v_9: G = G::from_u64(80); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(91); + let __v_12: G = G::from_u64(137); + let __v_13: G = G::from_u64(31); + let __v_14: G = G::from_u64(162); + let __v_15: G = G::from_u64(103); + let __v_16: G = G::from_u64(219); + let __v_17: G = G::from_u64(77); + let __v_18: G = G::from_u64(78); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(70); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(7); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(130); + let __v_25: G = G::from_u64(250); + let __v_26: G = G::from_u64(43); + let __v_27: G = G::from_u64(227); + let __v_28: G = G::from_u64(232); + let __v_29: G = G::from_u64(135); + let __v_30: G = G::from_u64(129); + let __v_31: G = G::from_u64(161); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_275] = [__v_32]; + record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_276: usize = 0; +const IN_276: usize = 0; +const OUT_276: usize = 1; +fn aiur_fn_276( + inp: [G; IN_276], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_276], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(252); + let __v_1: G = G::from_u64(14); + let __v_2: G = G::from_u64(30); + let __v_3: G = G::from_u64(145); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(45); + let __v_6: G = G::from_u64(127); + let __v_7: G = G::from_u64(18); + let __v_8: G = G::from_u64(4); + let __v_9: G = G::from_u64(154); + let __v_10: G = G::from_u64(91); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(93); + let __v_13: G = G::from_u64(118); + let __v_14: G = G::from_u64(238); + let __v_15: G = G::from_u64(194); + let __v_16: G = G::from_u64(149); + let __v_17: G = G::from_u64(98); + let __v_18: G = G::from_u64(227); + let __v_19: G = G::from_u64(77); + let __v_20: G = G::from_u64(195); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(188); + let __v_23: G = G::from_u64(162); + let __v_24: G = G::from_u64(82); + let __v_25: G = G::from_u64(135); + let __v_26: G = G::from_u64(174); + let __v_27: G = G::from_u64(88); + let __v_28: G = G::from_u64(128); + let __v_29: G = G::from_u64(125); + let __v_30: G = G::from_u64(177); + let __v_31: G = G::from_u64(55); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_276] = [__v_32]; + record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_277: usize = 0; +const IN_277: usize = 0; +const OUT_277: usize = 1; +fn aiur_fn_277( + inp: [G; IN_277], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_277], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(250); + let __v_1: G = G::from_u64(200); + let __v_2: G = G::from_u64(47); + let __v_3: G = G::from_u64(13); + let __v_4: G = G::from_u64(37); + let __v_5: G = G::from_u64(85); + let __v_6: G = G::from_u64(214); + let __v_7: G = G::from_u64(166); + let __v_8: G = G::from_u64(62); + let __v_9: G = G::from_u64(27); + let __v_10: G = G::from_u64(138); + let __v_11: G = G::from_u64(31); + let __v_12: G = G::from_u64(232); + let __v_13: G = G::from_u64(216); + let __v_14: G = G::from_u64(107); + let __v_15: G = G::from_u64(210); + let __v_16: G = G::from_u64(147); + let __v_17: G = G::from_u64(25); + let __v_18: G = G::from_u64(127); + let __v_19: G = G::from_u64(57); + let __v_20: G = G::from_u64(195); + let __v_21: G = G::from_u64(150); + let __v_22: G = G::from_u64(253); + let __v_23: G = G::from_u64(194); + let __v_24: G = G::from_u64(60); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(117); + let __v_27: G = G::from_u64(198); + let __v_28: G = G::from_u64(15); + let __v_29: G = G::from_u64(24); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(55); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_277] = [__v_32]; + record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_278: usize = 0; +const IN_278: usize = 0; +const OUT_278: usize = 1; +fn aiur_fn_278( + inp: [G; IN_278], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_278], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(113); + let __v_1: G = G::from_u64(144); + let __v_2: G = G::from_u64(206); + let __v_3: G = G::from_u64(86); + let __v_4: G = G::from_u64(246); + let __v_5: G = G::from_u64(162); + let __v_6: G = G::from_u64(168); + let __v_7: G = G::from_u64(71); + let __v_8: G = G::from_u64(185); + let __v_9: G = G::from_u64(68); + let __v_10: G = G::from_u64(163); + let __v_11: G = G::from_u64(85); + let __v_12: G = G::from_u64(227); + let __v_13: G = G::from_u64(236); + let __v_14: G = G::from_u64(89); + let __v_15: G = G::from_u64(90); + let __v_16: G = G::from_u64(64); + let __v_17: G = G::from_u64(54); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(227); + let __v_21: G = G::from_u64(195); + let __v_22: G = G::from_u64(219); + let __v_23: G = G::from_u64(157); + let __v_24: G = G::from_u64(144); + let __v_25: G = G::from_u64(100); + let __v_26: G = G::from_u64(252); + let __v_27: G = G::from_u64(4); + let __v_28: G = G::from_u64(27); + let __v_29: G = G::from_u64(231); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(100); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_278] = [__v_32]; + record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_279: usize = 0; +const IN_279: usize = 0; +const OUT_279: usize = 1; +fn aiur_fn_279( + inp: [G; IN_279], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_279], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(78); + let __v_1: G = G::from_u64(213); + let __v_2: G = G::from_u64(255); + let __v_3: G = G::from_u64(251); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(174); + let __v_6: G = G::from_u64(94); + let __v_7: G = G::from_u64(107); + let __v_8: G = G::from_u64(122); + let __v_9: G = G::from_u64(13); + let __v_10: G = G::from_u64(159); + let __v_11: G = G::from_u64(51); + let __v_12: G = G::from_u64(121); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(118); + let __v_15: G = G::from_u64(158); + let __v_16: G = G::from_u64(92); + let __v_17: G = G::from_u64(168); + let __v_18: G = G::from_u64(24); + let __v_19: G = G::from_u64(140); + let __v_20: G = G::from_u64(172); + let __v_21: G = G::from_u64(189); + let __v_22: G = G::from_u64(241); + let __v_23: G = G::from_u64(226); + let __v_24: G = G::from_u64(13); + let __v_25: G = G::from_u64(202); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(173); + let __v_28: G = G::from_u64(39); + let __v_29: G = G::from_u64(242); + let __v_30: G = G::from_u64(83); + let __v_31: G = G::from_u64(51); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_279] = [__v_32]; + record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_280: usize = 0; +const IN_280: usize = 0; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_280], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(157); + let __v_1: G = G::from_u64(131); + let __v_2: G = G::from_u64(48); + let __v_3: G = G::from_u64(125); + let __v_4: G = G::from_u64(85); + let __v_5: G = G::from_u64(46); + let __v_6: G = G::from_u64(104); + let __v_7: G = G::from_u64(31); + let __v_8: G = G::from_u64(76); + let __v_9: G = G::from_u64(206); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(120); + let __v_13: G = G::from_u64(59); + let __v_14: G = G::from_u64(90); + let __v_15: G = G::from_u64(100); + let __v_16: G = G::from_u64(224); + let __v_17: G = G::from_u64(2); + let __v_18: G = G::from_u64(87); + let __v_19: G = G::from_u64(94); + let __v_20: G = G::from_u64(220); + let __v_21: G = G::from_u64(177); + let __v_22: G = G::from_u64(192); + let __v_23: G = G::from_u64(79); + let __v_24: G = G::from_u64(160); + let __v_25: G = G::from_u64(197); + let __v_26: G = G::from_u64(102); + let __v_27: G = G::from_u64(44); + let __v_28: G = G::from_u64(226); + let __v_29: G = G::from_u64(221); + let __v_30: G = G::from_u64(52); + let __v_31: G = G::from_u64(56); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_280] = [__v_32]; + record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_281: usize = 0; +const IN_281: usize = 0; +const OUT_281: usize = 1; +fn aiur_fn_281( + inp: [G; IN_281], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_281], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(158); + let __v_1: G = G::from_u64(134); + let __v_2: G = G::from_u64(255); + let __v_3: G = G::from_u64(67); + let __v_4: G = G::from_u64(177); + let __v_5: G = G::from_u64(90); + let __v_6: G = G::from_u64(235); + let __v_7: G = G::from_u64(175); + let __v_8: G = G::from_u64(179); + let __v_9: G = G::from_u64(223); + let __v_10: G = G::from_u64(97); + let __v_11: G = G::from_u64(10); + let __v_12: G = G::from_u64(150); + let __v_13: G = G::from_u64(221); + let __v_14: G = G::from_u64(68); + let __v_15: G = G::from_u64(146); + let __v_16: G = G::from_u64(255); + let __v_17: G = G::from_u64(156); + let __v_18: G = G::from_u64(216); + let __v_19: G = G::from_u64(170); + let __v_20: G = G::from_u64(184); + let __v_21: G = G::from_u64(122); + let __v_22: G = G::from_u64(130); + let __v_23: G = G::from_u64(2); + let __v_24: G = G::from_u64(91); + let __v_25: G = G::from_u64(97); + let __v_26: G = G::from_u64(124); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(11); + let __v_29: G = G::from_u64(191); + let __v_30: G = G::from_u64(98); + let __v_31: G = G::from_u64(128); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_281] = [__v_32]; + record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_282: usize = 0; +const IN_282: usize = 0; +const OUT_282: usize = 1; +fn aiur_fn_282( + inp: [G; IN_282], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_282], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(155); + let __v_1: G = G::from_u64(193); + let __v_2: G = G::from_u64(53); + let __v_3: G = G::from_u64(57); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(14); + let __v_7: G = G::from_u64(28); + let __v_8: G = G::from_u64(90); + let __v_9: G = G::from_u64(83); + let __v_10: G = G::from_u64(129); + let __v_11: G = G::from_u64(133); + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(9); + let __v_15: G = G::from_u64(106); + let __v_16: G = G::from_u64(101); + let __v_17: G = G::from_u64(144); + let __v_18: G = G::from_u64(127); + let __v_19: G = G::from_u64(99); + let __v_20: G = G::from_u64(175); + let __v_21: G = G::from_u64(69); + let __v_22: G = G::from_u64(136); + let __v_23: G = G::from_u64(161); + let __v_24: G = G::from_u64(233); + let __v_25: G = G::from_u64(30); + let __v_26: G = G::from_u64(20); + let __v_27: G = G::from_u64(211); + let __v_28: G = G::from_u64(77); + let __v_29: G = G::from_u64(158); + let __v_30: G = G::from_u64(77); + let __v_31: G = G::from_u64(134); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_282] = [__v_32]; + record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_283: usize = 0; +const IN_283: usize = 0; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_283], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(181); + let __v_1: G = G::from_u64(44); + let __v_2: G = G::from_u64(77); + let __v_3: G = G::from_u64(13); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(120); + let __v_6: G = G::from_u64(242); + let __v_7: G = G::from_u64(135); + let __v_8: G = G::from_u64(113); + let __v_9: G = G::from_u64(159); + let __v_10: G = G::from_u64(101); + let __v_11: G = G::from_u64(208); + let __v_12: G = G::from_u64(8); + let __v_13: G = G::from_u64(138); + let __v_14: G = G::from_u64(38); + let __v_15: G = G::from_u64(154); + let __v_16: G = G::from_u64(240); + let __v_17: G = G::from_u64(246); + let __v_18: G = G::from_u64(229); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(183); + let __v_21: G = G::from_u64(239); + let __v_22: G = G::from_u64(86); + let __v_23: G = G::from_u64(41); + let __v_24: G = G::from_u64(131); + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(99); + let __v_27: G = G::from_u64(220); + let __v_28: G = G::from_u64(183); + let __v_29: G = G::from_u64(94); + let __v_30: G = G::from_u64(108); + let __v_31: G = G::from_u64(238); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_283] = [__v_32]; + record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_284: usize = 0; +const IN_284: usize = 0; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_284], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(116); + let __v_1: G = G::from_u64(54); + let __v_2: G = G::from_u64(217); + let __v_3: G = G::from_u64(250); + let __v_4: G = G::from_u64(124); + let __v_5: G = G::from_u64(206); + let __v_6: G = G::from_u64(62); + let __v_7: G = G::from_u64(249); + let __v_8: G = G::from_u64(27); + let __v_9: G = G::from_u64(201); + let __v_10: G = G::from_u64(144); + let __v_11: G = G::from_u64(60); + let __v_12: G = G::from_u64(197); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(50); + let __v_15: G = G::from_u64(212); + let __v_16: G = G::from_u64(19); + let __v_17: G = G::from_u64(218); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(108); + let __v_20: G = G::from_u64(167); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(26); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(53); + let __v_25: G = G::from_u64(180); + let __v_26: G = G::from_u64(26); + let __v_27: G = G::from_u64(47); + let __v_28: G = G::from_u64(196); + let __v_29: G = G::from_u64(130); + let __v_30: G = G::from_u64(223); + let __v_31: G = G::from_u64(252); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_284] = [__v_32]; + record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_285: usize = 0; +const IN_285: usize = 0; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_285], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(161); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(79); + let __v_4: G = G::from_u64(115); + let __v_5: G = G::from_u64(120); + let __v_6: G = G::from_u64(227); + let __v_7: G = G::from_u64(114); + let __v_8: G = G::from_u64(254); + let __v_9: G = G::from_u64(181); + let __v_10: G = G::from_u64(143); + let __v_11: G = G::from_u64(181); + let __v_12: G = G::from_u64(44); + let __v_13: G = G::from_u64(128); + let __v_14: G = G::from_u64(132); + let __v_15: G = G::from_u64(98); + let __v_16: G = G::from_u64(96); + let __v_17: G = G::from_u64(87); + let __v_18: G = G::from_u64(179); + let __v_19: G = G::from_u64(243); + let __v_20: G = G::from_u64(135); + let __v_21: G = G::from_u64(73); + let __v_22: G = G::from_u64(94); + let __v_23: G = G::from_u64(118); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(185); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(163); + let __v_28: G = G::from_u64(139); + let __v_29: G = G::from_u64(36); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(118); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_285] = [__v_32]; + record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_286: usize = 0; +const IN_286: usize = 0; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_286], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(208); + let __v_1: G = G::from_u64(145); + let __v_2: G = G::from_u64(149); + let __v_3: G = G::from_u64(112); + let __v_4: G = G::from_u64(248); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(45); + let __v_7: G = G::from_u64(223); + let __v_8: G = G::from_u64(93); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(67); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(171); + let __v_13: G = G::from_u64(118); + let __v_14: G = G::from_u64(103); + let __v_15: G = G::from_u64(209); + let __v_16: G = G::from_u64(186); + let __v_17: G = G::from_u64(171); + let __v_18: G = G::from_u64(147); + let __v_19: G = G::from_u64(36); + let __v_20: G = G::from_u64(219); + let __v_21: G = G::from_u64(193); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(172); + let __v_24: G = G::from_u64(156); + let __v_25: G = G::from_u64(129); + let __v_26: G = G::from_u64(41); + let __v_27: G = G::from_u64(46); + let __v_28: G = G::from_u64(209); + let __v_29: G = G::from_u64(200); + let __v_30: G = G::from_u64(31); + let __v_31: G = G::from_u64(233); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_286] = [__v_32]; + record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_287: usize = 0; +const IN_287: usize = 0; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_287], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(68); + let __v_1: G = G::from_u64(81); + let __v_2: G = G::from_u64(67); + let __v_3: G = G::from_u64(32); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(53); + let __v_7: G = G::from_u64(160); + let __v_8: G = G::from_u64(137); + let __v_9: G = G::from_u64(66); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(125); + let __v_12: G = G::from_u64(232); + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(126); + let __v_15: G = G::from_u64(56); + let __v_16: G = G::from_u64(63); + let __v_17: G = G::from_u64(17); + let __v_18: G = G::from_u64(160); + let __v_19: G = G::from_u64(246); + let __v_20: G = G::from_u64(21); + let __v_21: G = G::from_u64(12); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(12); + let __v_24: G = G::from_u64(152); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(200); + let __v_27: G = G::from_u64(116); + let __v_28: G = G::from_u64(103); + let __v_29: G = G::from_u64(88); + let __v_30: G = G::from_u64(153); + let __v_31: G = G::from_u64(101); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_287] = [__v_32]; + record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_288: usize = 0; +const IN_288: usize = 0; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: [G; IN_288], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_288], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(24); + let __v_1: G = G::from_u64(76); + let __v_2: G = G::from_u64(166); + let __v_3: G = G::from_u64(169); + let __v_4: G = G::from_u64(50); + let __v_5: G = G::from_u64(164); + let __v_6: G = G::from_u64(197); + let __v_7: G = G::from_u64(253); + let __v_8: G = G::from_u64(10); + let __v_9: G = G::from_u64(44); + let __v_10: G = G::from_u64(22); + let __v_11: G = G::from_u64(149); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(210); + let __v_14: G = G::from_u64(213); + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(139); + let __v_17: G = G::from_u64(183); + let __v_18: G = G::from_u64(67); + let __v_19: G = G::from_u64(189); + let __v_20: G = G::from_u64(22); + let __v_21: G = G::from_u64(111); + let __v_22: G = G::from_u64(150); + let __v_23: G = G::from_u64(255); + let __v_24: G = G::from_u64(236); + let __v_25: G = G::from_u64(157); + let __v_26: G = G::from_u64(65); + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(229); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(152); + let __v_31: G = G::from_u64(43); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_288] = [__v_32]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_289: usize = 0; +const IN_289: usize = 0; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_289], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(58); + let __v_2: G = G::from_u64(140); + let __v_3: G = G::from_u64(40); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(202); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(218); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(254); + let __v_10: G = G::from_u64(27); + let __v_11: G = G::from_u64(113); + let __v_12: G = G::from_u64(87); + let __v_13: G = G::from_u64(81); + let __v_14: G = G::from_u64(39); + let __v_15: G = G::from_u64(148); + let __v_16: G = G::from_u64(42); + let __v_17: G = G::from_u64(5); + let __v_18: G = G::from_u64(48); + let __v_19: G = G::from_u64(4); + let __v_20: G = G::from_u64(64); + let __v_21: G = G::from_u64(82); + let __v_22: G = G::from_u64(75); + let __v_23: G = G::from_u64(20); + let __v_24: G = G::from_u64(92); + let __v_25: G = G::from_u64(143); + let __v_26: G = G::from_u64(205); + let __v_27: G = G::from_u64(204); + let __v_28: G = G::from_u64(94); + let __v_29: G = G::from_u64(224); + let __v_30: G = G::from_u64(8); + let __v_31: G = G::from_u64(182); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_289] = [__v_32]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_290: usize = 0; +const IN_290: usize = 0; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: [G; IN_290], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_290], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(189); + let __v_2: G = G::from_u64(16); + let __v_3: G = G::from_u64(54); + let __v_4: G = G::from_u64(94); + let __v_5: G = G::from_u64(230); + let __v_6: G = G::from_u64(250); + let __v_7: G = G::from_u64(64); + let __v_8: G = G::from_u64(180); + let __v_9: G = G::from_u64(161); + let __v_10: G = G::from_u64(221); + let __v_11: G = G::from_u64(192); + let __v_12: G = G::from_u64(221); + let __v_13: G = G::from_u64(38); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(164); + let __v_16: G = G::from_u64(157); + let __v_17: G = G::from_u64(184); + let __v_18: G = G::from_u64(248); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(235); + let __v_21: G = G::from_u64(86); + let __v_22: G = G::from_u64(178); + let __v_23: G = G::from_u64(172); + let __v_24: G = G::from_u64(42); + let __v_25: G = G::from_u64(23); + let __v_26: G = G::from_u64(158); + let __v_27: G = G::from_u64(162); + let __v_28: G = G::from_u64(68); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(152); + let __v_31: G = G::from_u64(215); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_290] = [__v_32]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_291: usize = 0; +const IN_291: usize = 0; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_291], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(111); + let __v_1: G = G::from_u64(226); + let __v_2: G = G::from_u64(30); + let __v_3: G = G::from_u64(53); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(163); + let __v_6: G = G::from_u64(8); + let __v_7: G = G::from_u64(222); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(229); + let __v_10: G = G::from_u64(50); + let __v_11: G = G::from_u64(16); + let __v_12: G = G::from_u64(219); + let __v_13: G = G::from_u64(91); + let __v_14: G = G::from_u64(40); + let __v_15: G = G::from_u64(86); + let __v_16: G = G::from_u64(193); + let __v_17: G = G::from_u64(133); + let __v_18: G = G::from_u64(220); + let __v_19: G = G::from_u64(20); + let __v_20: G = G::from_u64(126); + let __v_21: G = G::from_u64(242); + let __v_22: G = G::from_u64(113); + let __v_23: G = G::from_u64(124); + let __v_24: G = G::from_u64(14); + let __v_25: G = G::from_u64(115); + let __v_26: G = G::from_u64(160); + let __v_27: G = G::from_u64(250); + let __v_28: G = G::from_u64(58); + let __v_29: G = G::from_u64(211); + let __v_30: G = G::from_u64(22); + let __v_31: G = G::from_u64(144); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_291] = [__v_32]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_292: usize = 0; +const IN_292: usize = 0; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_292], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(73); + let __v_1: G = G::from_u64(161); + let __v_2: G = G::from_u64(103); + let __v_3: G = G::from_u64(20); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(123); + let __v_6: G = G::from_u64(130); + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(124); + let __v_9: G = G::from_u64(216); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(118); + let __v_12: G = G::from_u64(51); + let __v_13: G = G::from_u64(29); + let __v_14: G = G::from_u64(130); + let __v_15: G = G::from_u64(98); + let __v_16: G = G::from_u64(130); + let __v_17: G = G::from_u64(155); + let __v_18: G = G::from_u64(199); + let __v_19: G = G::from_u64(12); + let __v_20: G = G::from_u64(142); + let __v_21: G = G::from_u64(227); + let __v_22: G = G::from_u64(99); + let __v_23: G = G::from_u64(200); + let __v_24: G = G::from_u64(102); + let __v_25: G = G::from_u64(199); + let __v_26: G = G::from_u64(6); + let __v_27: G = G::from_u64(11); + let __v_28: G = G::from_u64(243); + let __v_29: G = G::from_u64(102); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(155); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_292] = [__v_32]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_293: usize = 0; +const IN_293: usize = 0; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_293], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(245); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(36); + let __v_3: G = G::from_u64(87); + let __v_4: G = G::from_u64(103); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(188); + let __v_7: G = G::from_u64(104); + let __v_8: G = G::from_u64(59); + let __v_9: G = G::from_u64(238); + let __v_10: G = G::from_u64(158); + let __v_11: G = G::from_u64(28); + let __v_12: G = G::from_u64(168); + let __v_13: G = G::from_u64(217); + let __v_14: G = G::from_u64(167); + let __v_15: G = G::from_u64(36); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(36); + let __v_20: G = G::from_u64(198); + let __v_21: G = G::from_u64(123); + let __v_22: G = G::from_u64(44); + let __v_23: G = G::from_u64(63); + let __v_24: G = G::from_u64(34); + let __v_25: G = G::from_u64(125); + let __v_26: G = G::from_u64(229); + let __v_27: G = G::from_u64(27); + let __v_28: G = G::from_u64(95); + let __v_29: G = G::from_u64(131); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(38); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_293] = [__v_32]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_294: usize = 0; +const IN_294: usize = 0; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_294], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(38); + let __v_2: G = G::from_u64(88); + let __v_3: G = G::from_u64(208); + let __v_4: G = G::from_u64(67); + let __v_5: G = G::from_u64(238); + let __v_6: G = G::from_u64(72); + let __v_7: G = G::from_u64(47); + let __v_8: G = G::from_u64(113); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(210); + let __v_11: G = G::from_u64(246); + let __v_12: G = G::from_u64(234); + let __v_13: G = G::from_u64(101); + let __v_14: G = G::from_u64(150); + let __v_15: G = G::from_u64(102); + let __v_16: G = G::from_u64(72); + let __v_17: G = G::from_u64(8); + let __v_18: G = G::from_u64(232); + let __v_19: G = G::from_u64(153); + let __v_20: G = G::from_u64(171); + let __v_21: G = G::from_u64(173); + let __v_22: G = G::from_u64(98); + let __v_23: G = G::from_u64(128); + let __v_24: G = G::from_u64(128); + let __v_25: G = G::from_u64(71); + let __v_26: G = G::from_u64(138); + let __v_27: G = G::from_u64(30); + let __v_28: G = G::from_u64(145); + let __v_29: G = G::from_u64(137); + let __v_30: G = G::from_u64(240); + let __v_31: G = G::from_u64(170); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_294] = [__v_32]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_295: usize = 0; +const IN_295: usize = 0; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_295], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(204); + let __v_1: G = G::from_u64(108); + let __v_2: G = G::from_u64(220); + let __v_3: G = G::from_u64(115); + let __v_4: G = G::from_u64(224); + let __v_5: G = G::from_u64(223); + let __v_6: G = G::from_u64(64); + let __v_7: G = G::from_u64(75); + let __v_8: G = G::from_u64(167); + let __v_9: G = G::from_u64(104); + let __v_10: G = G::from_u64(92); + let __v_11: G = G::from_u64(115); + let __v_12: G = G::from_u64(62); + let __v_13: G = G::from_u64(187); + let __v_14: G = G::from_u64(231); + let __v_15: G = G::from_u64(193); + let __v_16: G = G::from_u64(174); + let __v_17: G = G::from_u64(204); + let __v_18: G = G::from_u64(110); + let __v_19: G = G::from_u64(244); + let __v_20: G = G::from_u64(101); + let __v_21: G = G::from_u64(3); + let __v_22: G = G::from_u64(209); + let __v_23: G = G::from_u64(10); + let __v_24: G = G::from_u64(173); + let __v_25: G = G::from_u64(88); + let __v_26: G = G::from_u64(191); + let __v_27: G = G::from_u64(112); + let __v_28: G = G::from_u64(248); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(72); + let __v_31: G = G::from_u64(88); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_295] = [__v_32]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_296: usize = 0; +const IN_296: usize = 0; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_296], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(246); + let __v_1: G = G::from_u64(6); + let __v_2: G = G::from_u64(111); + let __v_3: G = G::from_u64(198); + let __v_4: G = G::from_u64(36); + let __v_5: G = G::from_u64(145); + let __v_6: G = G::from_u64(253); + let __v_7: G = G::from_u64(76); + let __v_8: G = G::from_u64(72); + let __v_9: G = G::from_u64(212); + let __v_10: G = G::from_u64(218); + let __v_11: G = G::from_u64(243); + let __v_12: G = G::from_u64(185); + let __v_13: G = G::from_u64(190); + let __v_14: G = G::from_u64(186); + let __v_15: G = G::from_u64(114); + let __v_16: G = G::from_u64(226); + let __v_17: G = G::from_u64(160); + let __v_18: G = G::from_u64(184); + let __v_19: G = G::from_u64(4); + let __v_20: G = G::from_u64(15); + let __v_21: G = G::from_u64(203); + let __v_22: G = G::from_u64(217); + let __v_23: G = G::from_u64(159); + let __v_24: G = G::from_u64(183); + let __v_25: G = G::from_u64(41); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(245); + let __v_28: G = G::from_u64(106); + let __v_29: G = G::from_u64(156); + let __v_30: G = G::from_u64(7); + let __v_31: G = G::from_u64(196); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_296] = [__v_32]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_297: usize = 0; +const IN_297: usize = 0; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_297], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(213); + let __v_1: G = G::from_u64(229); + let __v_2: G = G::from_u64(67); + let __v_3: G = G::from_u64(165); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(189); + let __v_6: G = G::from_u64(232); + let __v_7: G = G::from_u64(141); + let __v_8: G = G::from_u64(195); + let __v_9: G = G::from_u64(133); + let __v_10: G = G::from_u64(77); + let __v_11: G = G::from_u64(76); + let __v_12: G = G::from_u64(43); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(18); + let __v_15: G = G::from_u64(172); + let __v_16: G = G::from_u64(39); + let __v_17: G = G::from_u64(9); + let __v_18: G = G::from_u64(118); + let __v_19: G = G::from_u64(191); + let __v_20: G = G::from_u64(65); + let __v_21: G = G::from_u64(2); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(179); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(85); + let __v_26: G = G::from_u64(169); + let __v_27: G = G::from_u64(13); + let __v_28: G = G::from_u64(179); + let __v_29: G = G::from_u64(36); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(143); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_297] = [__v_32]; + record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_298: usize = 0; +const IN_298: usize = 0; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: [G; IN_298], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_298], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(160); + let __v_1: G = G::from_u64(119); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(236); + let __v_4: G = G::from_u64(153); + let __v_5: G = G::from_u64(159); + let __v_6: G = G::from_u64(220); + let __v_7: G = G::from_u64(184); + let __v_8: G = G::from_u64(117); + let __v_9: G = G::from_u64(48); + let __v_10: G = G::from_u64(103); + let __v_11: G = G::from_u64(73); + let __v_12: G = G::from_u64(127); + let __v_13: G = G::from_u64(159); + let __v_14: G = G::from_u64(151); + let __v_15: G = G::from_u64(180); + let __v_16: G = G::from_u64(97); + let __v_17: G = G::from_u64(242); + let __v_18: G = G::from_u64(161); + let __v_19: G = G::from_u64(78); + let __v_20: G = G::from_u64(129); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(205); + let __v_23: G = G::from_u64(17); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(125); + let __v_26: G = G::from_u64(199); + let __v_27: G = G::from_u64(60); + let __v_28: G = G::from_u64(223); + let __v_29: G = G::from_u64(215); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(170); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_298] = [__v_32]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_299: usize = 0; +const IN_299: usize = 0; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_299], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(192); + let __v_1: G = G::from_u64(127); + let __v_2: G = G::from_u64(21); + let __v_3: G = G::from_u64(137); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(125); + let __v_6: G = G::from_u64(204); + let __v_7: G = G::from_u64(85); + let __v_8: G = G::from_u64(110); + let __v_9: G = G::from_u64(56); + let __v_10: G = G::from_u64(78); + let __v_11: G = G::from_u64(66); + let __v_12: G = G::from_u64(186); + let __v_13: G = G::from_u64(177); + let __v_14: G = G::from_u64(66); + let __v_15: G = G::from_u64(168); + let __v_16: G = G::from_u64(79); + let __v_17: G = G::from_u64(122); + let __v_18: G = G::from_u64(98); + let __v_19: G = G::from_u64(85); + let __v_20: G = G::from_u64(211); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(89); + let __v_23: G = G::from_u64(176); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(25); + let __v_27: G = G::from_u64(128); + let __v_28: G = G::from_u64(71); + let __v_29: G = G::from_u64(37); + let __v_30: G = G::from_u64(34); + let __v_31: G = G::from_u64(150); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_299] = [__v_32]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_300: usize = 0; +const IN_300: usize = 0; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_300], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(40); + let __v_1: G = G::from_u64(220); + let __v_2: G = G::from_u64(27); + let __v_3: G = G::from_u64(61); + let __v_4: G = G::from_u64(61); + let __v_5: G = G::from_u64(46); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(21); + let __v_8: G = G::from_u64(41); + let __v_9: G = G::from_u64(199); + let __v_10: G = G::from_u64(28); + let __v_11: G = G::from_u64(157); + let __v_12: G = G::from_u64(68); + let __v_13: G = G::from_u64(24); + let __v_14: G = G::from_u64(36); + let __v_15: G = G::from_u64(143); + let __v_16: G = G::from_u64(96); + let __v_17: G = G::from_u64(96); + let __v_18: G = G::from_u64(219); + let __v_19: G = G::from_u64(251); + let __v_20: G = G::from_u64(28); + let __v_21: G = G::from_u64(126); + let __v_22: G = G::from_u64(151); + let __v_23: G = G::from_u64(219); + let __v_24: G = G::from_u64(28); + let __v_25: G = G::from_u64(87); + let __v_26: G = G::from_u64(42); + let __v_27: G = G::from_u64(86); + let __v_28: G = G::from_u64(87); + let __v_29: G = G::from_u64(135); + let __v_30: G = G::from_u64(239); + let __v_31: G = G::from_u64(97); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_300] = [__v_32]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_301: usize = 0; +const IN_301: usize = 0; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_301], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(47); + let __v_1: G = G::from_u64(150); + let __v_2: G = G::from_u64(184); + let __v_3: G = G::from_u64(218); + let __v_4: G = G::from_u64(41); + let __v_5: G = G::from_u64(163); + let __v_6: G = G::from_u64(139); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(127); + let __v_9: G = G::from_u64(195); + let __v_10: G = G::from_u64(37); + let __v_11: G = G::from_u64(83); + let __v_12: G = G::from_u64(213); + let __v_13: G = G::from_u64(56); + let __v_14: G = G::from_u64(213); + let __v_15: G = G::from_u64(212); + let __v_16: G = G::from_u64(80); + let __v_17: G = G::from_u64(33); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(211); + let __v_20: G = G::from_u64(230); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(217); + let __v_23: G = G::from_u64(93); + let __v_24: G = G::from_u64(97); + let __v_25: G = G::from_u64(200); + let __v_26: G = G::from_u64(23); + let __v_27: G = G::from_u64(131); + let __v_28: G = G::from_u64(125); + let __v_29: G = G::from_u64(41); + let __v_30: G = G::from_u64(163); + let __v_31: G = G::from_u64(79); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_301] = [__v_32]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_302: usize = 0; +const IN_302: usize = 0; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_302], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(64); + let __v_1: G = G::from_u64(93); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(245); + let __v_4: G = G::from_u64(246); + let __v_5: G = G::from_u64(71); + let __v_6: G = G::from_u64(156); + let __v_7: G = G::from_u64(64); + let __v_8: G = G::from_u64(33); + let __v_9: G = G::from_u64(111); + let __v_10: G = G::from_u64(247); + let __v_11: G = G::from_u64(187); + let __v_12: G = G::from_u64(186); + let __v_13: G = G::from_u64(16); + let __v_14: G = G::from_u64(176); + let __v_15: G = G::from_u64(119); + let __v_16: G = G::from_u64(132); + let __v_17: G = G::from_u64(142); + let __v_18: G = G::from_u64(195); + let __v_19: G = G::from_u64(58); + let __v_20: G = G::from_u64(240); + let __v_21: G = G::from_u64(62); + let __v_22: G = G::from_u64(244); + let __v_23: G = G::from_u64(4); + let __v_24: G = G::from_u64(11); + let __v_25: G = G::from_u64(250); + let __v_26: G = G::from_u64(79); + let __v_27: G = G::from_u64(130); + let __v_28: G = G::from_u64(147); + let __v_29: G = G::from_u64(13); + let __v_30: G = G::from_u64(228); + let __v_31: G = G::from_u64(186); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_302] = [__v_32]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_303: usize = 0; +const IN_303: usize = 0; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_303], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(14); + let __v_1: G = G::from_u64(190); + let __v_2: G = G::from_u64(52); + let __v_3: G = G::from_u64(93); + let __v_4: G = G::from_u64(196); + let __v_5: G = G::from_u64(105); + let __v_6: G = G::from_u64(23); + let __v_7: G = G::from_u64(200); + let __v_8: G = G::from_u64(36); + let __v_9: G = G::from_u64(182); + let __v_10: G = G::from_u64(195); + let __v_11: G = G::from_u64(246); + let __v_12: G = G::from_u64(196); + let __v_13: G = G::from_u64(43); + let __v_14: G = G::from_u64(16); + let __v_15: G = G::from_u64(31); + let __v_16: G = G::from_u64(42); + let __v_17: G = G::from_u64(200); + let __v_18: G = G::from_u64(192); + let __v_19: G = G::from_u64(226); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(159); + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(58); + let __v_24: G = G::from_u64(14); + let __v_25: G = G::from_u64(227); + let __v_26: G = G::from_u64(198); + let __v_27: G = G::from_u64(10); + let __v_28: G = G::from_u64(203); + let __v_29: G = G::from_u64(156); + let __v_30: G = G::from_u64(216); + let __v_31: G = G::from_u64(77); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_303] = [__v_32]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_304: usize = 0; +const IN_304: usize = 0; +const OUT_304: usize = 1; +fn aiur_fn_304( + inp: [G; IN_304], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_304], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(247); + let __v_1: G = G::from_u64(152); + let __v_2: G = G::from_u64(66); + let __v_3: G = G::from_u64(241); + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(6); + let __v_6: G = G::from_u64(89); + let __v_7: G = G::from_u64(137); + let __v_8: G = G::from_u64(41); + let __v_9: G = G::from_u64(230); + let __v_10: G = G::from_u64(186); + let __v_11: G = G::from_u64(96); + let __v_12: G = G::from_u64(206); + let __v_13: G = G::from_u64(62); + let __v_14: G = G::from_u64(186); + let __v_15: G = G::from_u64(160); + let __v_16: G = G::from_u64(13); + let __v_17: G = G::from_u64(17); + let __v_18: G = G::from_u64(242); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(128); + let __v_23: G = G::from_u64(40); + let __v_24: G = G::from_u64(95); + let __v_25: G = G::from_u64(70); + let __v_26: G = G::from_u64(204); + let __v_27: G = G::from_u64(14); + let __v_28: G = G::from_u64(144); + let __v_29: G = G::from_u64(147); + let __v_30: G = G::from_u64(40); + let __v_31: G = G::from_u64(50); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_304] = [__v_32]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_305: usize = 0; +const IN_305: usize = 0; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_305], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(13); + let __v_2: G = G::from_u64(234); + let __v_3: G = G::from_u64(210); + let __v_4: G = G::from_u64(22); + let __v_5: G = G::from_u64(138); + let __v_6: G = G::from_u64(189); + let __v_7: G = G::from_u64(22); + let __v_8: G = G::from_u64(167); + let __v_9: G = G::from_u64(5); + let __v_10: G = G::from_u64(14); + let __v_11: G = G::from_u64(223); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(225); + let __v_14: G = G::from_u64(125); + let __v_15: G = G::from_u64(69); + let __v_16: G = G::from_u64(21); + let __v_17: G = G::from_u64(82); + let __v_18: G = G::from_u64(55); + let __v_19: G = G::from_u64(211); + let __v_20: G = G::from_u64(17); + let __v_21: G = G::from_u64(135); + let __v_22: G = G::from_u64(130); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(109); + let __v_27: G = G::from_u64(232); + let __v_28: G = G::from_u64(119); + let __v_29: G = G::from_u64(66); + let __v_30: G = G::from_u64(203); + let __v_31: G = G::from_u64(141); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_305] = [__v_32]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_306: usize = 0; +const IN_306: usize = 0; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_306], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(193); + let __v_1: G = G::from_u64(39); + let __v_2: G = G::from_u64(248); + let __v_3: G = G::from_u64(159); + let __v_4: G = G::from_u64(146); + let __v_5: G = G::from_u64(224); + let __v_6: G = G::from_u64(72); + let __v_7: G = G::from_u64(31); + let __v_8: G = G::from_u64(122); + let __v_9: G = G::from_u64(62); + let __v_10: G = G::from_u64(6); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(197); + let __v_13: G = G::from_u64(97); + let __v_14: G = G::from_u64(95); + let __v_15: G = G::from_u64(231); + let __v_16: G = G::from_u64(246); + let __v_17: G = G::from_u64(203); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(67); + let __v_20: G = G::from_u64(157); + let __v_21: G = G::from_u64(95); + let __v_22: G = G::from_u64(215); + let __v_23: G = G::from_u64(235); + let __v_24: G = G::from_u64(164); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(251); + let __v_27: G = G::from_u64(6); + let __v_28: G = G::from_u64(3); + let __v_29: G = G::from_u64(174); + let __v_30: G = G::from_u64(223); + let __v_31: G = G::from_u64(47); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_306] = [__v_32]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_307: usize = 1; +const IN_307: usize = 1; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_307], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_307] = [__v_23]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = __r_arr[8]; + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_307] = [__v_29]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_307] = [__v_30]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_308: usize = 3; +const IN_308: usize = 3; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_308], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_308] = [__v_1]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_13]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_308] = [__v_0]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_23]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = (__v_31 + __v_47); + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_12, __v_22, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = result.output.try_into().unwrap(); __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_308] = [__v_51]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_309: usize = 2; +const IN_309: usize = 2; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_309], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = result.output.try_into().unwrap(); __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_309] = [__v_3]; + record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_310: usize = 16; +const IN_310: usize = 16; +const OUT_310: usize = 9; +fn aiur_fn_310( + inp: [G; IN_310], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_310], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_0, &__v_8); let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.push(Bytes2::sub(&__v_0, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_16: G = __b2_sub.0; + let __v_17: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_1, &__v_9); let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.push(Bytes2::sub(&__v_1, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_18: G = __b2_sub.0; + let __v_19: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_18, &__v_17); let mut __scratch: Vec = vec![__v_18, __v_17]; if unconstrained { __scratch.push(Bytes2::sub(&__v_18, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_20: G = __b2_sub.0; + let __v_21: G = __b2_sub.1; + let __v_22: G = (__v_19 + __v_21); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_2, &__v_10); let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.push(Bytes2::sub(&__v_2, &__v_10).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_23: G = __b2_sub.0; + let __v_24: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_23, &__v_22); let mut __scratch: Vec = vec![__v_23, __v_22]; if unconstrained { __scratch.push(Bytes2::sub(&__v_23, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_25: G = __b2_sub.0; + let __v_26: G = __b2_sub.1; + let __v_27: G = (__v_24 + __v_26); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_3, &__v_11); let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.push(Bytes2::sub(&__v_3, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_28: G = __b2_sub.0; + let __v_29: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_28, &__v_27); let mut __scratch: Vec = vec![__v_28, __v_27]; if unconstrained { __scratch.push(Bytes2::sub(&__v_28, &__v_27).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_30: G = __b2_sub.0; + let __v_31: G = __b2_sub.1; + let __v_32: G = (__v_29 + __v_31); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_4, &__v_12); let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.push(Bytes2::sub(&__v_4, &__v_12).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_33: G = __b2_sub.0; + let __v_34: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_33, &__v_32); let mut __scratch: Vec = vec![__v_33, __v_32]; if unconstrained { __scratch.push(Bytes2::sub(&__v_33, &__v_32).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_35: G = __b2_sub.0; + let __v_36: G = __b2_sub.1; + let __v_37: G = (__v_34 + __v_36); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_5, &__v_13); let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.push(Bytes2::sub(&__v_5, &__v_13).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_38: G = __b2_sub.0; + let __v_39: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_38, &__v_37); let mut __scratch: Vec = vec![__v_38, __v_37]; if unconstrained { __scratch.push(Bytes2::sub(&__v_38, &__v_37).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_40: G = __b2_sub.0; + let __v_41: G = __b2_sub.1; + let __v_42: G = (__v_39 + __v_41); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_6, &__v_14); let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.push(Bytes2::sub(&__v_6, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_43: G = __b2_sub.0; + let __v_44: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_43, &__v_42); let mut __scratch: Vec = vec![__v_43, __v_42]; if unconstrained { __scratch.push(Bytes2::sub(&__v_43, &__v_42).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_45: G = __b2_sub.0; + let __v_46: G = __b2_sub.1; + let __v_47: G = (__v_44 + __v_46); + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_7, &__v_15); let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.push(Bytes2::sub(&__v_7, &__v_15).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_48: G = __b2_sub.0; + let __v_49: G = __b2_sub.1; + let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_48, &__v_47); let mut __scratch: Vec = vec![__v_48, __v_47]; if unconstrained { __scratch.push(Bytes2::sub(&__v_48, &__v_47).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __v_50: G = __b2_sub.0; + let __v_51: G = __b2_sub.1; + let __v_52: G = (__v_49 + __v_51); + let __ret: [G; OUT_310] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_311: usize = 3; +const IN_311: usize = 3; +const OUT_311: usize = 2; +fn aiur_fn_311( + inp: [G; IN_311], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_311], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_311] = [__v_25, __v_2]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(1); + let __ret: [G; OUT_311] = [__v_25, __v_26]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_311] = [__v_0, __v_23]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = G::from_u64(1); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_42, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_311] = [__v_46, __v_44]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = (__v_31 + __v_47); + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_22, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_311] = [__v_52, __v_50]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_312: usize = 1; +const IN_312: usize = 1; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_312], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_312] = [__v_13]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_312] = [__v_25]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(1); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_312] = [__v_27]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_312] = [__v_23]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_313: usize = 2; +const IN_313: usize = 2; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_313], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_313] = [__v_7]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_313] = [__v_5]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_314: usize = 2; +const IN_314: usize = 2; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_314], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_314] = [__v_13]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_314] = [__v_13]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_315: usize = 1; +const IN_315: usize = 1; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_315], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_315] = [__v_14]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_316: usize = 2; +const IN_316: usize = 2; +const OUT_316: usize = 2; +fn aiur_fn_316( + inp: [G; IN_316], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_316], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(256); + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_316] = [__v_0, __v_1]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(256); + let __v_5: G = (__v_0 - __v_4); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_316] = [__v_8, __v_9]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_317: usize = 1; +const IN_317: usize = 1; +const OUT_317: usize = 3; +fn aiur_fn_317( + inp: [G; IN_317], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_317], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_317] = [__v_2, __v_5, __v_6]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_318: usize = 16; +const IN_318: usize = 16; +const OUT_318: usize = 16; +fn aiur_fn_318( + inp: [G; IN_318], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_318], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = (__v_0 * __v_8); + let __v_17: G = (__v_0 * __v_9); + let __v_18: G = (__v_1 * __v_8); + let __v_19: G = (__v_17 + __v_18); + let __v_20: G = (__v_0 * __v_10); + let __v_21: G = (__v_1 * __v_9); + let __v_22: G = (__v_2 * __v_8); + let __v_23: G = (__v_21 + __v_22); + let __v_24: G = (__v_20 + __v_23); + let __v_25: G = (__v_0 * __v_11); + let __v_26: G = (__v_1 * __v_10); + let __v_27: G = (__v_2 * __v_9); + let __v_28: G = (__v_3 * __v_8); + let __v_29: G = (__v_27 + __v_28); + let __v_30: G = (__v_26 + __v_29); + let __v_31: G = (__v_25 + __v_30); + let __v_32: G = (__v_0 * __v_12); + let __v_33: G = (__v_1 * __v_11); + let __v_34: G = (__v_2 * __v_10); + let __v_35: G = (__v_3 * __v_9); + let __v_36: G = (__v_4 * __v_8); + let __v_37: G = (__v_35 + __v_36); + let __v_38: G = (__v_34 + __v_37); + let __v_39: G = (__v_33 + __v_38); + let __v_40: G = (__v_32 + __v_39); + let __v_41: G = (__v_0 * __v_13); + let __v_42: G = (__v_1 * __v_12); + let __v_43: G = (__v_2 * __v_11); + let __v_44: G = (__v_3 * __v_10); + let __v_45: G = (__v_4 * __v_9); + let __v_46: G = (__v_5 * __v_8); + let __v_47: G = (__v_45 + __v_46); + let __v_48: G = (__v_44 + __v_47); + let __v_49: G = (__v_43 + __v_48); + let __v_50: G = (__v_42 + __v_49); + let __v_51: G = (__v_41 + __v_50); + let __v_52: G = (__v_0 * __v_14); + let __v_53: G = (__v_1 * __v_13); + let __v_54: G = (__v_2 * __v_12); + let __v_55: G = (__v_3 * __v_11); + let __v_56: G = (__v_4 * __v_10); + let __v_57: G = (__v_5 * __v_9); + let __v_58: G = (__v_6 * __v_8); + let __v_59: G = (__v_57 + __v_58); + let __v_60: G = (__v_56 + __v_59); + let __v_61: G = (__v_55 + __v_60); + let __v_62: G = (__v_54 + __v_61); + let __v_63: G = (__v_53 + __v_62); + let __v_64: G = (__v_52 + __v_63); + let __v_65: G = (__v_0 * __v_15); + let __v_66: G = (__v_1 * __v_14); + let __v_67: G = (__v_2 * __v_13); + let __v_68: G = (__v_3 * __v_12); + let __v_69: G = (__v_4 * __v_11); + let __v_70: G = (__v_5 * __v_10); + let __v_71: G = (__v_6 * __v_9); + let __v_72: G = (__v_7 * __v_8); + let __v_73: G = (__v_71 + __v_72); + let __v_74: G = (__v_70 + __v_73); + let __v_75: G = (__v_69 + __v_74); + let __v_76: G = (__v_68 + __v_75); + let __v_77: G = (__v_67 + __v_76); + let __v_78: G = (__v_66 + __v_77); + let __v_79: G = (__v_65 + __v_78); + let __v_80: G = (__v_1 * __v_15); + let __v_81: G = (__v_2 * __v_14); + let __v_82: G = (__v_3 * __v_13); + let __v_83: G = (__v_4 * __v_12); + let __v_84: G = (__v_5 * __v_11); + let __v_85: G = (__v_6 * __v_10); + let __v_86: G = (__v_7 * __v_9); + let __v_87: G = (__v_85 + __v_86); + let __v_88: G = (__v_84 + __v_87); + let __v_89: G = (__v_83 + __v_88); + let __v_90: G = (__v_82 + __v_89); + let __v_91: G = (__v_81 + __v_90); + let __v_92: G = (__v_80 + __v_91); + let __v_93: G = (__v_2 * __v_15); + let __v_94: G = (__v_3 * __v_14); + let __v_95: G = (__v_4 * __v_13); + let __v_96: G = (__v_5 * __v_12); + let __v_97: G = (__v_6 * __v_11); + let __v_98: G = (__v_7 * __v_10); + let __v_99: G = (__v_97 + __v_98); + let __v_100: G = (__v_96 + __v_99); + let __v_101: G = (__v_95 + __v_100); + let __v_102: G = (__v_94 + __v_101); + let __v_103: G = (__v_93 + __v_102); + let __v_104: G = (__v_3 * __v_15); + let __v_105: G = (__v_4 * __v_14); + let __v_106: G = (__v_5 * __v_13); + let __v_107: G = (__v_6 * __v_12); + let __v_108: G = (__v_7 * __v_11); + let __v_109: G = (__v_107 + __v_108); + let __v_110: G = (__v_106 + __v_109); + let __v_111: G = (__v_105 + __v_110); + let __v_112: G = (__v_104 + __v_111); + let __v_113: G = (__v_4 * __v_15); + let __v_114: G = (__v_5 * __v_14); + let __v_115: G = (__v_6 * __v_13); + let __v_116: G = (__v_7 * __v_12); + let __v_117: G = (__v_115 + __v_116); + let __v_118: G = (__v_114 + __v_117); + let __v_119: G = (__v_113 + __v_118); + let __v_120: G = (__v_5 * __v_15); + let __v_121: G = (__v_6 * __v_14); + let __v_122: G = (__v_7 * __v_13); + let __v_123: G = (__v_121 + __v_122); + let __v_124: G = (__v_120 + __v_123); + let __v_125: G = (__v_6 * __v_15); + let __v_126: G = (__v_7 * __v_14); + let __v_127: G = (__v_125 + __v_126); + let __v_128: G = (__v_7 * __v_15); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_16]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_129: G = __r_arr[0]; + let __v_130: G = __r_arr[1]; + let __v_131: G = __r_arr[2]; + let __v_132: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_129, __v_132]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_129, &__v_132)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_133: G = __b2_out[0]; + let __v_134: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_130, __v_134]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_130, &__v_134)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_135: G = __b2_out[0]; + let __v_136: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_131, __v_136]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_131, &__v_136)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_137: G = __b2_out[0]; + let __v_138: G = G::from_u64(256); + let __v_139: G = (__v_138 * __v_135); + let __v_140: G = G::from_u64(65536); + let __v_141: G = (__v_140 * __v_137); + let __v_142: G = (__v_139 + __v_141); + let __v_143: G = (__v_133 + __v_142); + if (__v_16 != __v_143) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_143.as_canonical_u64() }); + } + let __v_144: G = G::from_u64(256); + let __v_145: G = (__v_144 * __v_137); + let __v_146: G = (__v_135 + __v_145); + let __v_147: G = (__v_19 + __v_146); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_147]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_148: G = __r_arr[0]; + let __v_149: G = __r_arr[1]; + let __v_150: G = __r_arr[2]; + let __v_151: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_148, __v_151]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_148, &__v_151)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_152: G = __b2_out[0]; + let __v_153: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_149, __v_153]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_149, &__v_153)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_154: G = __b2_out[0]; + let __v_155: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_150, __v_155]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_150, &__v_155)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_156: G = __b2_out[0]; + let __v_157: G = G::from_u64(256); + let __v_158: G = (__v_157 * __v_154); + let __v_159: G = G::from_u64(65536); + let __v_160: G = (__v_159 * __v_156); + let __v_161: G = (__v_158 + __v_160); + let __v_162: G = (__v_152 + __v_161); + if (__v_147 != __v_162) { + return Err(ExecError::AssertEqMismatch { lhs: __v_147.as_canonical_u64(), rhs: __v_162.as_canonical_u64() }); + } + let __v_163: G = G::from_u64(256); + let __v_164: G = (__v_163 * __v_156); + let __v_165: G = (__v_154 + __v_164); + let __v_166: G = (__v_24 + __v_165); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_166]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_167: G = __r_arr[0]; + let __v_168: G = __r_arr[1]; + let __v_169: G = __r_arr[2]; + let __v_170: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_167, __v_170]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_167, &__v_170)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_171: G = __b2_out[0]; + let __v_172: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_168, __v_172]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_168, &__v_172)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_173: G = __b2_out[0]; + let __v_174: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_169, __v_174]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_169, &__v_174)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_175: G = __b2_out[0]; + let __v_176: G = G::from_u64(256); + let __v_177: G = (__v_176 * __v_173); + let __v_178: G = G::from_u64(65536); + let __v_179: G = (__v_178 * __v_175); + let __v_180: G = (__v_177 + __v_179); + let __v_181: G = (__v_171 + __v_180); + if (__v_166 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_181.as_canonical_u64() }); + } + let __v_182: G = G::from_u64(256); + let __v_183: G = (__v_182 * __v_175); + let __v_184: G = (__v_173 + __v_183); + let __v_185: G = (__v_31 + __v_184); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_185]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_186: G = __r_arr[0]; + let __v_187: G = __r_arr[1]; + let __v_188: G = __r_arr[2]; + let __v_189: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_186, __v_189]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_186, &__v_189)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_190: G = __b2_out[0]; + let __v_191: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_187, __v_191]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_187, &__v_191)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_192: G = __b2_out[0]; + let __v_193: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_188, __v_193]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_188, &__v_193)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_194: G = __b2_out[0]; + let __v_195: G = G::from_u64(256); + let __v_196: G = (__v_195 * __v_192); + let __v_197: G = G::from_u64(65536); + let __v_198: G = (__v_197 * __v_194); + let __v_199: G = (__v_196 + __v_198); + let __v_200: G = (__v_190 + __v_199); + if (__v_185 != __v_200) { + return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_200.as_canonical_u64() }); + } + let __v_201: G = G::from_u64(256); + let __v_202: G = (__v_201 * __v_194); + let __v_203: G = (__v_192 + __v_202); + let __v_204: G = (__v_40 + __v_203); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_204]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_205: G = __r_arr[0]; + let __v_206: G = __r_arr[1]; + let __v_207: G = __r_arr[2]; + let __v_208: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_205, __v_208]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_205, &__v_208)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_209: G = __b2_out[0]; + let __v_210: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_206, __v_210]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_206, &__v_210)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_211: G = __b2_out[0]; + let __v_212: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_207, __v_212]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_207, &__v_212)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_213: G = __b2_out[0]; + let __v_214: G = G::from_u64(256); + let __v_215: G = (__v_214 * __v_211); + let __v_216: G = G::from_u64(65536); + let __v_217: G = (__v_216 * __v_213); + let __v_218: G = (__v_215 + __v_217); + let __v_219: G = (__v_209 + __v_218); + if (__v_204 != __v_219) { + return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_219.as_canonical_u64() }); + } + let __v_220: G = G::from_u64(256); + let __v_221: G = (__v_220 * __v_213); + let __v_222: G = (__v_211 + __v_221); + let __v_223: G = (__v_51 + __v_222); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_223]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_224: G = __r_arr[0]; + let __v_225: G = __r_arr[1]; + let __v_226: G = __r_arr[2]; + let __v_227: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_224, __v_227]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_224, &__v_227)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_228: G = __b2_out[0]; + let __v_229: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_225, __v_229]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_225, &__v_229)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_230: G = __b2_out[0]; + let __v_231: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_226, __v_231]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_226, &__v_231)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_232: G = __b2_out[0]; + let __v_233: G = G::from_u64(256); + let __v_234: G = (__v_233 * __v_230); + let __v_235: G = G::from_u64(65536); + let __v_236: G = (__v_235 * __v_232); + let __v_237: G = (__v_234 + __v_236); + let __v_238: G = (__v_228 + __v_237); + if (__v_223 != __v_238) { + return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_238.as_canonical_u64() }); + } + let __v_239: G = G::from_u64(256); + let __v_240: G = (__v_239 * __v_232); + let __v_241: G = (__v_230 + __v_240); + let __v_242: G = (__v_64 + __v_241); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_242]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_243: G = __r_arr[0]; + let __v_244: G = __r_arr[1]; + let __v_245: G = __r_arr[2]; + let __v_246: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_243, __v_246]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_243, &__v_246)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_247: G = __b2_out[0]; + let __v_248: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_244, __v_248]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_244, &__v_248)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_249: G = __b2_out[0]; + let __v_250: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_245, __v_250]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_245, &__v_250)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_251: G = __b2_out[0]; + let __v_252: G = G::from_u64(256); + let __v_253: G = (__v_252 * __v_249); + let __v_254: G = G::from_u64(65536); + let __v_255: G = (__v_254 * __v_251); + let __v_256: G = (__v_253 + __v_255); + let __v_257: G = (__v_247 + __v_256); + if (__v_242 != __v_257) { + return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_257.as_canonical_u64() }); + } + let __v_258: G = G::from_u64(256); + let __v_259: G = (__v_258 * __v_251); + let __v_260: G = (__v_249 + __v_259); + let __v_261: G = (__v_79 + __v_260); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_261]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_262: G = __r_arr[0]; + let __v_263: G = __r_arr[1]; + let __v_264: G = __r_arr[2]; + let __v_265: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_262, __v_265]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_262, &__v_265)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_266: G = __b2_out[0]; + let __v_267: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_263, __v_267]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_263, &__v_267)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_268: G = __b2_out[0]; + let __v_269: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_264, __v_269]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_264, &__v_269)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_270: G = __b2_out[0]; + let __v_271: G = G::from_u64(256); + let __v_272: G = (__v_271 * __v_268); + let __v_273: G = G::from_u64(65536); + let __v_274: G = (__v_273 * __v_270); + let __v_275: G = (__v_272 + __v_274); + let __v_276: G = (__v_266 + __v_275); + if (__v_261 != __v_276) { + return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_276.as_canonical_u64() }); + } + let __v_277: G = G::from_u64(256); + let __v_278: G = (__v_277 * __v_270); + let __v_279: G = (__v_268 + __v_278); + let __v_280: G = (__v_92 + __v_279); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_280]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_281: G = __r_arr[0]; + let __v_282: G = __r_arr[1]; + let __v_283: G = __r_arr[2]; + let __v_284: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_281, __v_284]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_281, &__v_284)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_285: G = __b2_out[0]; + let __v_286: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_282, __v_286]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_282, &__v_286)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_287: G = __b2_out[0]; + let __v_288: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_283, __v_288]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_283, &__v_288)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_289: G = __b2_out[0]; + let __v_290: G = G::from_u64(256); + let __v_291: G = (__v_290 * __v_287); + let __v_292: G = G::from_u64(65536); + let __v_293: G = (__v_292 * __v_289); + let __v_294: G = (__v_291 + __v_293); + let __v_295: G = (__v_285 + __v_294); + if (__v_280 != __v_295) { + return Err(ExecError::AssertEqMismatch { lhs: __v_280.as_canonical_u64(), rhs: __v_295.as_canonical_u64() }); + } + let __v_296: G = G::from_u64(256); + let __v_297: G = (__v_296 * __v_289); + let __v_298: G = (__v_287 + __v_297); + let __v_299: G = (__v_103 + __v_298); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_299]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_300: G = __r_arr[0]; + let __v_301: G = __r_arr[1]; + let __v_302: G = __r_arr[2]; + let __v_303: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_300, __v_303]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_300, &__v_303)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_304: G = __b2_out[0]; + let __v_305: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_301, __v_305]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_301, &__v_305)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_306: G = __b2_out[0]; + let __v_307: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_302, __v_307]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_302, &__v_307)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_308: G = __b2_out[0]; + let __v_309: G = G::from_u64(256); + let __v_310: G = (__v_309 * __v_306); + let __v_311: G = G::from_u64(65536); + let __v_312: G = (__v_311 * __v_308); + let __v_313: G = (__v_310 + __v_312); + let __v_314: G = (__v_304 + __v_313); + if (__v_299 != __v_314) { + return Err(ExecError::AssertEqMismatch { lhs: __v_299.as_canonical_u64(), rhs: __v_314.as_canonical_u64() }); + } + let __v_315: G = G::from_u64(256); + let __v_316: G = (__v_315 * __v_308); + let __v_317: G = (__v_306 + __v_316); + let __v_318: G = (__v_112 + __v_317); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_318]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_319: G = __r_arr[0]; + let __v_320: G = __r_arr[1]; + let __v_321: G = __r_arr[2]; + let __v_322: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_319, __v_322]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_319, &__v_322)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_323: G = __b2_out[0]; + let __v_324: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_320, __v_324]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_320, &__v_324)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_325: G = __b2_out[0]; + let __v_326: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_321, __v_326]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_321, &__v_326)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_327: G = __b2_out[0]; + let __v_328: G = G::from_u64(256); + let __v_329: G = (__v_328 * __v_325); + let __v_330: G = G::from_u64(65536); + let __v_331: G = (__v_330 * __v_327); + let __v_332: G = (__v_329 + __v_331); + let __v_333: G = (__v_323 + __v_332); + if (__v_318 != __v_333) { + return Err(ExecError::AssertEqMismatch { lhs: __v_318.as_canonical_u64(), rhs: __v_333.as_canonical_u64() }); + } + let __v_334: G = G::from_u64(256); + let __v_335: G = (__v_334 * __v_327); + let __v_336: G = (__v_325 + __v_335); + let __v_337: G = (__v_119 + __v_336); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_337]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_338: G = __r_arr[0]; + let __v_339: G = __r_arr[1]; + let __v_340: G = __r_arr[2]; + let __v_341: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_338, __v_341]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_338, &__v_341)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_342: G = __b2_out[0]; + let __v_343: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_339, __v_343]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_339, &__v_343)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_344: G = __b2_out[0]; + let __v_345: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_340, __v_345]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_340, &__v_345)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_346: G = __b2_out[0]; + let __v_347: G = G::from_u64(256); + let __v_348: G = (__v_347 * __v_344); + let __v_349: G = G::from_u64(65536); + let __v_350: G = (__v_349 * __v_346); + let __v_351: G = (__v_348 + __v_350); + let __v_352: G = (__v_342 + __v_351); + if (__v_337 != __v_352) { + return Err(ExecError::AssertEqMismatch { lhs: __v_337.as_canonical_u64(), rhs: __v_352.as_canonical_u64() }); + } + let __v_353: G = G::from_u64(256); + let __v_354: G = (__v_353 * __v_346); + let __v_355: G = (__v_344 + __v_354); + let __v_356: G = (__v_124 + __v_355); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_356]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_357: G = __r_arr[0]; + let __v_358: G = __r_arr[1]; + let __v_359: G = __r_arr[2]; + let __v_360: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_357, __v_360]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_357, &__v_360)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_361: G = __b2_out[0]; + let __v_362: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_358, __v_362]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_358, &__v_362)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_363: G = __b2_out[0]; + let __v_364: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_359, __v_364]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_359, &__v_364)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_365: G = __b2_out[0]; + let __v_366: G = G::from_u64(256); + let __v_367: G = (__v_366 * __v_363); + let __v_368: G = G::from_u64(65536); + let __v_369: G = (__v_368 * __v_365); + let __v_370: G = (__v_367 + __v_369); + let __v_371: G = (__v_361 + __v_370); + if (__v_356 != __v_371) { + return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_371.as_canonical_u64() }); + } + let __v_372: G = G::from_u64(256); + let __v_373: G = (__v_372 * __v_365); + let __v_374: G = (__v_363 + __v_373); + let __v_375: G = (__v_127 + __v_374); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_375]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_376: G = __r_arr[0]; + let __v_377: G = __r_arr[1]; + let __v_378: G = __r_arr[2]; + let __v_379: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_376, __v_379]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_376, &__v_379)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_380: G = __b2_out[0]; + let __v_381: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_377, __v_381]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_377, &__v_381)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_382: G = __b2_out[0]; + let __v_383: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_378, __v_383]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_378, &__v_383)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_384: G = __b2_out[0]; + let __v_385: G = G::from_u64(256); + let __v_386: G = (__v_385 * __v_382); + let __v_387: G = G::from_u64(65536); + let __v_388: G = (__v_387 * __v_384); + let __v_389: G = (__v_386 + __v_388); + let __v_390: G = (__v_380 + __v_389); + if (__v_375 != __v_390) { + return Err(ExecError::AssertEqMismatch { lhs: __v_375.as_canonical_u64(), rhs: __v_390.as_canonical_u64() }); + } + let __v_391: G = G::from_u64(256); + let __v_392: G = (__v_391 * __v_384); + let __v_393: G = (__v_382 + __v_392); + let __v_394: G = (__v_128 + __v_393); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_394]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_395: G = __r_arr[0]; + let __v_396: G = __r_arr[1]; + let __v_397: G = __r_arr[2]; + let __v_398: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_395, __v_398]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_395, &__v_398)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_399: G = __b2_out[0]; + let __v_400: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_396, __v_400]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_396, &__v_400)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_401: G = __b2_out[0]; + let __v_402: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_397, __v_402]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_397, &__v_402)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_403: G = __b2_out[0]; + let __v_404: G = G::from_u64(256); + let __v_405: G = (__v_404 * __v_401); + let __v_406: G = G::from_u64(65536); + let __v_407: G = (__v_406 * __v_403); + let __v_408: G = (__v_405 + __v_407); + let __v_409: G = (__v_399 + __v_408); + if (__v_394 != __v_409) { + return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_409.as_canonical_u64() }); + } + let __v_410: G = G::from_u64(256); + let __v_411: G = (__v_410 * __v_403); + let __v_412: G = (__v_401 + __v_411); + let __ret: [G; OUT_318] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_412]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_319], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = result.output.try_into().unwrap(); __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_319] = [__v_6]; + record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_320: usize = 4; +const IN_320: usize = 4; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_320], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_320] = [__v_2]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = result.output.try_into().unwrap(); __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_25, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = result.output.try_into().unwrap(); __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_2, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(1); + let __v_29: G = (__v_3 + __v_28); + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = result.output.try_into().unwrap(); __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_320] = [__v_30]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_321: usize = 18; +const IN_321: usize = 18; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_321], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + match __v_28.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_321] = [__v_17]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_321] = [__v_29]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = result.output.try_into().unwrap(); __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __v_38: G = __r_arr[10]; + let __v_39: G = __r_arr[11]; + let __v_40: G = __r_arr[12]; + let __v_41: G = __r_arr[13]; + let __v_42: G = __r_arr[14]; + let __v_43: G = __r_arr[15]; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = __r_arr[1]; + let __v_62: G = __r_arr[2]; + let __v_63: G = __r_arr[3]; + let __v_64: G = __r_arr[4]; + let __v_65: G = __r_arr[5]; + let __v_66: G = __r_arr[6]; + let __v_67: G = __r_arr[7]; + let __v_68: G = __r_arr[8]; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = result.output.try_into().unwrap(); __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __ret: [G; OUT_321] = [__v_70]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_322: usize = 2; +const IN_322: usize = 2; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_322], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_322] = [__v_0]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 - __v_12); + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = result.output.try_into().unwrap(); __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_322] = [__v_14]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_323: usize = 1; +const IN_323: usize = 1; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_323], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_323] = [__v_12]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_323] = [__v_12]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 2; +fn aiur_fn_324( + inp: [G; IN_324], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_324], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; + let __v_2: G = __bu_qr.0; + let __v_3: G = __bu_qr.1; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + if (__v_6 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_324] = [__v_2, __v_3]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + if (__v_10 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + let __ret: [G; OUT_324] = [__v_2, __v_3]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_325], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __ret: [G; OUT_325] = [__v_2]; + record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_326], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __ret: [G; OUT_326] = [__v_3]; + record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_327: usize = 2; +const IN_327: usize = 2; +const OUT_327: usize = 1; +fn aiur_fn_327( + inp: [G; IN_327], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_327], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_327] = [__v_0]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = result.output.try_into().unwrap(); __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_327] = [__v_4]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 1; +fn aiur_fn_328( + inp: [G; IN_328], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_328], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_328] = [__v_15]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_328] = [__v_21]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_328] = [__v_23]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_329: usize = 16; +const IN_329: usize = 16; +const OUT_329: usize = 8; +fn aiur_fn_329( + inp: [G; IN_329], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_329], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_16: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_17: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_18: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_19: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_20: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_21: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_22: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_23: G = __b2_out[0]; + let __ret: [G; OUT_329] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_330: usize = 16; +const IN_330: usize = 16; +const OUT_330: usize = 8; +fn aiur_fn_330( + inp: [G; IN_330], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_330], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_16: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_17: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_18: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_19: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_20: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_21: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_22: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_23: G = __b2_out[0]; + let __ret: [G; OUT_330] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_331: usize = 16; +const IN_331: usize = 16; +const OUT_331: usize = 8; +fn aiur_fn_331( + inp: [G; IN_331], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_331], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_16: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_17: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_18: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_19: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_20: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_21: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_22: G = __b2_out[0]; + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_23: G = __b2_out[0]; + let __ret: [G; OUT_331] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_332: usize = 2; +const IN_332: usize = 2; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_332], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_332] = [__v_14]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_332] = [__v_24]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = result.output.try_into().unwrap(); __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = result.output.try_into().unwrap(); __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_332] = [__v_32]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_333: usize = 2; +const IN_333: usize = 2; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_333], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_333] = [__v_1]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_333] = [__v_0]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = result.output.try_into().unwrap(); __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = result.output.try_into().unwrap(); __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_333] = [__v_32]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_334], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_334] = [__v_1]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_334] = [__v_0]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = result.output.try_into().unwrap(); __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = result.output.try_into().unwrap(); __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_334] = [__v_32]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_335: usize = 2; +const IN_335: usize = 2; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_335], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_335] = [__v_16]; + record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_336: usize = 2; +const IN_336: usize = 2; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_336], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = result.output.try_into().unwrap(); __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_336] = [__v_16]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_337: usize = 3; +const IN_337: usize = 3; +const OUT_337: usize = 2; +fn aiur_fn_337( + inp: [G; IN_337], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_337], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_337] = [__v_6, __v_7]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_337] = [__v_7, __v_2]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_337] = [__v_9, __v_10]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_338: usize = 3; +const IN_338: usize = 3; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_338], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(2); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_13, __v_1, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_338] = [__v_18]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(2); + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(1); + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_16, __v_2, __v_19, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_338] = [__v_24]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_339: usize = 2; +const IN_339: usize = 2; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_339], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_9, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = result.output.try_into().unwrap(); __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_339] = [__v_14]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_340: usize = 2; +const IN_340: usize = 2; +const OUT_340: usize = 2; +fn aiur_fn_340( + inp: [G; IN_340], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_340], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_340] = [__v_6, __v_4]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_340] = [__v_6, __v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_340] = [__v_9, __v_12]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_340] = [__v_9, __v_12]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = result.output.try_into().unwrap(); __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __ret: [G; OUT_340] = [__v_6, __v_7]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_340] = [__v_6, __v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_341: usize = 3; +const IN_341: usize = 3; +const OUT_341: usize = 2; +fn aiur_fn_341( + inp: [G; IN_341], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_341], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_341] = [__v_12, __v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_341] = [__v_12, __v_15]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_341] = [__v_10, __v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_341] = [__v_7, __v_10]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_342: usize = 1; +const IN_342: usize = 1; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_342], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(7); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_342] = [__v_4]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_343: usize = 1; +const IN_343: usize = 1; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_343], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_85: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_86: G = __r_arr[0]; + let __v_87: G = (__v_84 + __v_86); + let __v_88: G = (__v_82 + __v_87); + let __v_89: G = (__v_80 + __v_88); + let __v_90: G = (__v_78 + __v_89); + let __v_91: G = (__v_76 + __v_90); + let __v_92: G = (__v_74 + __v_91); + let __v_93: G = (__v_72 + __v_92); + let __v_94: G = (__v_70 + __v_93); + let __v_95: G = (__v_68 + __v_94); + let __v_96: G = (__v_66 + __v_95); + let __v_97: G = (__v_64 + __v_96); + let __v_98: G = (__v_62 + __v_97); + let __v_99: G = (__v_60 + __v_98); + let __v_100: G = (__v_58 + __v_99); + let __v_101: G = (__v_56 + __v_100); + let __v_102: G = (__v_54 + __v_101); + let __v_103: G = (__v_52 + __v_102); + let __v_104: G = (__v_50 + __v_103); + let __v_105: G = (__v_48 + __v_104); + let __v_106: G = (__v_46 + __v_105); + let __v_107: G = (__v_44 + __v_106); + let __v_108: G = (__v_42 + __v_107); + let __v_109: G = (__v_40 + __v_108); + let __v_110: G = (__v_38 + __v_109); + let __v_111: G = (__v_36 + __v_110); + let __v_112: G = (__v_34 + __v_111); + let __v_113: G = (__v_32 + __v_112); + let __v_114: G = (__v_30 + __v_113); + let __v_115: G = (__v_28 + __v_114); + let __v_116: G = (__v_26 + __v_115); + let __v_117: G = (__v_24 + __v_116); + let __v_118: G = (__v_22 + __v_117); + let __v_119: G = (__v_20 + __v_118); + let __v_120: G = (__v_18 + __v_119); + let __v_121: G = (__v_16 + __v_120); + let __v_122: G = (__v_14 + __v_121); + let __v_123: G = (__v_12 + __v_122); + let __v_124: G = (__v_10 + __v_123); + let __v_125: G = (__v_8 + __v_124); + let __v_126: G = (__v_6 + __v_125); + let __v_127: G = (__v_4 + __v_126); + let __v_128: G = (__v_2 + __v_127); + let __ret: [G; OUT_343] = [__v_128]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_344: usize = 5; +const IN_344: usize = 5; +const OUT_344: usize = 2; +fn aiur_fn_344( + inp: [G; IN_344], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_344], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_12, __v_16]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_344] = [__v_19, __v_22]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_17, __v_21]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_12, __v_16]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_344] = [__v_19, __v_22]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_17, __v_21]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = result.output.try_into().unwrap(); __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_344] = [__v_10, __v_11]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_345: usize = 6; +const IN_345: usize = 6; +const OUT_345: usize = 2; +fn aiur_fn_345( + inp: [G; IN_345], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_345], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(2); + let __v_7: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_8, __v_12]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 1u64 => { + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_15, __v_17, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = result.output.try_into().unwrap(); __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_345] = [__v_22, __v_23]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_20, __v_24]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_18, __v_22]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_18, __v_22]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_346: usize = 4; +const IN_346: usize = 4; +const OUT_346: usize = 2; +fn aiur_fn_346( + inp: [G; IN_346], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_346], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_6, __v_9]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_8, __v_11]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_10, __v_13]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = result.output.try_into().unwrap(); __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_12, __v_15]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_14, __v_17]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = result.output.try_into().unwrap(); __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_16, __v_19]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_18, __v_21]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = result.output.try_into().unwrap(); __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_20, __v_23]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = result.output.try_into().unwrap(); __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_22, __v_25]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __v_24: G = G::from_u64(1); + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = result.output.try_into().unwrap(); __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_24, __v_27]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(1); + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = result.output.try_into().unwrap(); __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_26, __v_29]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 1u64 => { + let __v_28: G = G::from_u64(1); + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = result.output.try_into().unwrap(); __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_28, __v_31]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + match __v_29.as_canonical_u64() { + 1u64 => { + let __v_30: G = G::from_u64(1); + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_31, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_30, __v_32]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + match __v_31.as_canonical_u64() { + 1u64 => { + let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_33, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_32, __v_34]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_346] = [__v_32, __v_36]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_347: usize = 2; +const IN_347: usize = 2; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: [G; IN_347], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_347], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + break '__mc_0 [__v_2]; + }, + _ => { + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + break '__mc_0 [__v_2]; + }, +} + }; + let __v_2: G = __mc_out___mc_0[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(2); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_5, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_347] = [__v_11]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_347] = [__v_12]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(1); + let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_6, __v_7, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_347] = [__v_22]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_348: usize = 1; +const IN_348: usize = 1; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: [G; IN_348], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_348], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_348] = [__v_11]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(256); + let __v_12: G = (__v_11 * __v_3); + let __v_13: G = G::from_u64(65536); + let __v_14: G = (__v_13 * __v_4); + let __v_15: G = G::from_u64(16777216); + let __v_16: G = (__v_15 * __v_5); + let __v_17: G = (__v_14 + __v_16); + let __v_18: G = (__v_12 + __v_17); + let __v_19: G = (__v_2 + __v_18); + let __ret: [G; OUT_348] = [__v_19]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_349: usize = 4; +const IN_349: usize = 4; +const OUT_349: usize = 2; +fn aiur_fn_349( + inp: [G; IN_349], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_349], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(2); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_7, __v_11]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = result.output.try_into().unwrap(); __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_15, __v_19]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_15, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_18, __v_22]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_21, __v_25]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 10] = [__v_30, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 10] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_33, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_17, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(1); + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_349] = [__v_36, __v_37]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 3; +fn aiur_fn_350( + inp: [G; IN_350], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_350], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(2); + let __v_13: G = (__v_11 - __v_12); + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_350] = [__v_14, __v_16, __v_18]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_14, __v_18, __v_22]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(220); + let __v_13: G = G::from_u64(134); + let __v_14: G = G::from_u64(159); + let __v_15: G = G::from_u64(123); + let __v_16: G = G::from_u64(122); + let __v_17: G = G::from_u64(162); + let __v_18: G = G::from_u64(183); + let __v_19: G = G::from_u64(181); + let __v_20: G = G::from_u64(146); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(162); + let __v_23: G = G::from_u64(66); + let __v_24: G = G::from_u64(237); + let __v_25: G = G::from_u64(137); + let __v_26: G = G::from_u64(156); + let __v_27: G = G::from_u64(226); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(197); + let __v_30: G = G::from_u64(212); + let __v_31: G = G::from_u64(45); + let __v_32: G = G::from_u64(241); + let __v_33: G = G::from_u64(212); + let __v_34: G = G::from_u64(226); + let __v_35: G = G::from_u64(57); + let __v_36: G = G::from_u64(54); + let __v_37: G = G::from_u64(144); + let __v_38: G = G::from_u64(207); + let __v_39: G = G::from_u64(168); + let __v_40: G = G::from_u64(94); + let __v_41: G = G::from_u64(148); + let __v_42: G = G::from_u64(210); + let __v_43: G = { let __values: [G; 32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + match __v_44.as_canonical_u64() { + 0u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_50, __v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_45, __v_49, __v_53]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(2); + let __v_47: G = { let __a_val = __v_45.as_canonical_u64(); let __b_val = __v_46.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 4] = [__v_49, __v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_48, __v_52, __v_56]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + let __v_55: G = __loaded[3]; + match __v_52.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_56, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + match __v_58.as_canonical_u64() { + 0u64 => { + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 4] = [__v_60, __v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 4] = [__v_64, __v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_59, __v_63, __v_67]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_59 - __v_60); + match __v_61.as_canonical_u64() { + 0u64 => { + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_51, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __ret: [G; OUT_350] = [__v_62, __v_64, __v_66]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 4] = [__v_63, __v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 4] = [__v_67, __v_68, __v_69, __v_69]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_62, __v_66, __v_70]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); + }, + } + }, + _ => { + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = { let __values: [G; 4] = [__v_57, __v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_61, __v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_56, __v_60, __v_64]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_8, __v_12, __v_16]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_351: usize = 4; +const IN_351: usize = 4; +const OUT_351: usize = 2; +fn aiur_fn_351( + inp: [G; IN_351], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_351], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(3); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_7, __v_11]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = result.output.try_into().unwrap(); __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_12, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = result.output.try_into().unwrap(); __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_17, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_17, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_17 - __v_18); + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_19, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_351] = [__v_20, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_352: usize = 5; +const IN_352: usize = 5; +const OUT_352: usize = 2; +fn aiur_fn_352( + inp: [G; IN_352], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_352], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_1, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_5, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = result.output.try_into().unwrap(); __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_14, __v_17]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + match __v_14.as_canonical_u64() { + 7u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(1); + let __ret: [G; OUT_352] = [__v_18, __v_16]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_18, __v_21]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_18, __v_21]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_353: usize = 5; +const IN_353: usize = 5; +const OUT_353: usize = 2; +fn aiur_fn_353( + inp: [G; IN_353], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_353], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = result.output.try_into().unwrap(); __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_7, __v_8]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = result.output.try_into().unwrap(); __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_9, __v_10]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = result.output.try_into().unwrap(); __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_11, __v_12]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_353] = [__v_11, __v_15]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_354: usize = 4; +const IN_354: usize = 4; +const OUT_354: usize = 2; +fn aiur_fn_354( + inp: [G; IN_354], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_354], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(2); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_7, __v_11]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = result.output.try_into().unwrap(); __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_18, __v_22]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(4); + let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_21, __v_25]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + let __v_28: G = __loaded[3]; + match __v_25.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_32, __v_36]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_34.as_canonical_u64() { + 1u64 => { + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 4] = [__v_36, __v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_35, __v_39]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_24, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(1); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 3] = [__v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_43, __v_40, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_42, __v_38, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_41, __v_36, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = result.output.try_into().unwrap(); __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __ret: [G; OUT_354] = [__v_50, __v_51]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_29, __v_33]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_15, __v_19]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_355: usize = 5; +const IN_355: usize = 5; +const OUT_355: usize = 2; +fn aiur_fn_355( + inp: [G; IN_355], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_355], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = result.output.try_into().unwrap(); __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_355] = [__v_7, __v_8]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = result.output.try_into().unwrap(); __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_9, __v_10]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = result.output.try_into().unwrap(); __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_11, __v_12]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = result.output.try_into().unwrap(); __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_355] = [__v_13, __v_14]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = (__v_14 + __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_355] = [__v_18, __v_22]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_355] = [__v_21, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = result.output.try_into().unwrap(); __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_24, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = result.output.try_into().unwrap(); __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_24, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_356: usize = 0; +const IN_356: usize = 0; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_356], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(64); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_356] = [__v_16]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_357: usize = 0; +const IN_357: usize = 0; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_357], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_357] = [__v_16]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_358: usize = 2; +const IN_358: usize = 2; +const OUT_358: usize = 2; +fn aiur_fn_358( + inp: [G; IN_358], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_358], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(3); + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_358] = [__v_5, __v_9]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = result.output.try_into().unwrap(); __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_358] = [__v_16, __v_17]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_358] = [__v_16, __v_20]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_358] = [__v_13, __v_17]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_359: usize = 2; +const IN_359: usize = 2; +const OUT_359: usize = 2; +fn aiur_fn_359( + inp: [G; IN_359], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_359], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_359] = [__v_5, __v_9]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_15 + __v_17); + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_359] = [__v_19, __v_23]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = result.output.try_into().unwrap(); __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_359] = [__v_19, __v_20]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_359] = [__v_13, __v_17]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_360: usize = 2; +const IN_360: usize = 2; +const OUT_360: usize = 2; +fn aiur_fn_360( + inp: [G; IN_360], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_360], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = (__v_8 + __v_10); + match __v_11.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_360] = [__v_12, __v_16]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_360] = [__v_12, __v_0]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_360] = [__v_6, __v_10]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_361: usize = 1; +const IN_361: usize = 1; +const OUT_361: usize = 2; +fn aiur_fn_361( + inp: [G; IN_361], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_361], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 7u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_361] = [__v_5, __v_0]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_361] = [__v_5, __v_9]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_361] = [__v_5, __v_9]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_362: usize = 7; +const IN_362: usize = 7; +const OUT_362: usize = 2; +fn aiur_fn_362( + inp: [G; IN_362], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_362], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_16 + __v_18); + let __v_20: G = (__v_14 + __v_19); + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = result.output.try_into().unwrap(); __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_362] = [__v_21, __v_22]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_10 + __v_12); + let __v_22: G = (__v_8 + __v_21); + match __v_22.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_362] = [__v_23, __v_27]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(2); + let __v_25: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_24.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_362] = [__v_26, __v_30]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = result.output.try_into().unwrap(); __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_362] = [__v_26, __v_27]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_363: usize = 2; +const IN_363: usize = 2; +const OUT_363: usize = 3; +fn aiur_fn_363( + inp: [G; IN_363], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_363], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = (__v_12 + __v_14); + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_16, __v_17, __v_20]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __v_19: G = __loaded[3]; + match __v_16.as_canonical_u64() { + 7u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(1); + let __ret: [G; OUT_363] = [__v_20, __v_14, __v_18]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_20, __v_21, __v_24]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_20, __v_21, __v_24]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_10, __v_11, __v_14]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_6, __v_7, __v_10]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 2; +fn aiur_fn_364( + inp: [G; IN_364], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_364], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + break '__mc_0 [__v_3]; + }, + _ => { + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + break '__mc_0 [__v_3]; + }, +} + }; + let __v_3: G = __mc_out___mc_0[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_6, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(3); + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_364] = [__v_13, __v_17]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_364] = [__v_7, __v_11]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_365: usize = 6; +const IN_365: usize = 6; +const OUT_365: usize = 2; +fn aiur_fn_365( + inp: [G; IN_365], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_365], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(2); + let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_365] = [__v_9, __v_13]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_365] = [__v_19, __v_23]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = result.output.try_into().unwrap(); __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_365] = [__v_19, __v_20]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = result.output.try_into().unwrap(); __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_365] = [__v_16, __v_17]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_366: usize = 8; +const IN_366: usize = 8; +const OUT_366: usize = 2; +fn aiur_fn_366( + inp: [G; IN_366], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_366], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_9, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_12, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = result.output.try_into().unwrap(); __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_15, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = result.output.try_into().unwrap(); __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(2); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_20, __v_0, __v_1, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(3); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_23, __v_22, __v_17, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(3); + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_28, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_366] = [__v_31, __v_32]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_366] = [__v_20, __v_24]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_366] = [__v_18, __v_22]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_366] = [__v_16, __v_20]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_366] = [__v_13, __v_17]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_367: usize = 9; +const IN_367: usize = 9; +const OUT_367: usize = 2; +fn aiur_fn_367( + inp: [G; IN_367], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_367], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_367] = [__v_16, __v_20]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_18, __v_19, __v_22, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_25, __v_8, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_367] = [__v_29, __v_33]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_29: G = G::from_u64(2); + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_28, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(3); + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_34, __v_17, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(3); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_40, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(1); + let __ret: [G; OUT_367] = [__v_44, __v_43]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = result.output.try_into().unwrap(); __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_367] = [__v_9, __v_10]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_368: usize = 8; +const IN_368: usize = 8; +const OUT_368: usize = 2; +fn aiur_fn_368( + inp: [G; IN_368], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_368], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_11, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_368] = [__v_18, __v_22]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_368] = [__v_18, __v_22]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_15, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + break '__mc_0 [__v_18]; + }, + 0u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + break '__mc_0 [__v_18]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_18: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_18, __v_9, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = result.output.try_into().unwrap(); __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_368] = [__v_19, __v_20]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_369: usize = 11; +const IN_369: usize = 11; +const OUT_369: usize = 2; +fn aiur_fn_369( + inp: [G; IN_369], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_369], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_15, __v_19]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = result.output.try_into().unwrap(); __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_15, __v_10, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_19, __v_23]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + 0u64 => { + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, +} + }; + let __v_19: G = __mc_out___mc_0[0]; + let __v_20: G = __mc_out___mc_0[1]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_21, __v_25]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 3] = [__v_21, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_27, __v_26, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(2); + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 4] = [__v_32, __v_14, __v_31, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(2); + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_18, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(2); + let __v_42: G = G::from_u64(1); + let __v_43: G = G::from_u64(1); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 4] = [__v_41, __v_20, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = G::from_u64(3); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_34, __v_40, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(3); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_49, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = result.output.try_into().unwrap(); __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + 0u64 => { + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = result.output.try_into().unwrap(); __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = result.output.try_into().unwrap(); __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + 0u64 => { + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = result.output.try_into().unwrap(); __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_53: G = __mc_out___mc_1[0]; + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_53, __v_10, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + match __v_55.as_canonical_u64() { + 0u64 => { + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 4] = [__v_58, __v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_57, __v_61]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_57: G = G::from_u64(1); + let __v_58: G = (__v_57 - __v_2); + let __v_59: G = (__v_0 * __v_58); + match __v_59.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_61, __v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_60, __v_64]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_60: G = G::from_u64(2); + let __v_61: G = G::from_u64(1); + let __v_62: G = G::from_u64(1); + let __v_63: G = { let __values: [G; 3] = [__v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_60, __v_56, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(3); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_4, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(3); + let __v_73: G = G::from_u64(0); + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_52, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_2, __v_74, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = result.output.try_into().unwrap(); __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __ret: [G; OUT_369] = [__v_75, __v_76]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_370: usize = 8; +const IN_370: usize = 8; +const OUT_370: usize = 2; +fn aiur_fn_370( + inp: [G; IN_370], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_370], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = result.output.try_into().unwrap(); __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, + 0u64 => { + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = result.output.try_into().unwrap(); __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_8: G = __mc_out___mc_0[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_370] = [__v_12, __v_16]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(2); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_14, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_18, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __a_val = __v_22.as_canonical_u64(); let __b_val = __v_23.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_24.as_canonical_u64() { + 1u64 => { + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_370] = [__v_25, __v_29]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_21, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 4] = [__v_27, __v_11, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(3); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_26, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(3); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_38, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __ret: [G; OUT_370] = [__v_41, __v_42]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_371: usize = 3; +const IN_371: usize = 3; +const OUT_371: usize = 2; +fn aiur_fn_371( + inp: [G; IN_371], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_371], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_371] = [__v_6, __v_10]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 7u64 => { + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_22, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(7); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_26, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_371] = [__v_27, __v_31]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = result.output.try_into().unwrap(); __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_371] = [__v_16, __v_17]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_17 + __v_19); + match __v_20.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_371] = [__v_21, __v_25]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = result.output.try_into().unwrap(); __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_371] = [__v_21, __v_22]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_371] = [__v_12, __v_16]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_371] = [__v_12, __v_16]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_372: usize = 2; +const IN_372: usize = 2; +const OUT_372: usize = 2; +fn aiur_fn_372( + inp: [G; IN_372], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_372], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = result.output.try_into().unwrap(); __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(2); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_10, __v_8, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_372] = [__v_9, __v_15]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_372] = [__v_9, __v_13]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_372] = [__v_5, __v_9]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_373: usize = 2; +const IN_373: usize = 2; +const OUT_373: usize = 2; +fn aiur_fn_373( + inp: [G; IN_373], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_373], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_373] = [__v_6, __v_10]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = result.output.try_into().unwrap(); __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = result.output.try_into().unwrap(); __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(7); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(2); + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_12, __v_5, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(3); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_17, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_373] = [__v_18, __v_21]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_374: usize = 1; +const IN_374: usize = 1; +const OUT_374: usize = 4; +fn aiur_fn_374( + inp: [G; IN_374], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_374], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_374] = [__v_2, __v_5, __v_8, __v_11]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_375: usize = 1; +const IN_375: usize = 1; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: [G; IN_375], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_375], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = result.output.try_into().unwrap(); __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_6: G = __b2_out[0]; + let __v_7: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_8: G = __b2_out[0]; + let __v_9: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_10: G = __b2_out[0]; + let __v_11: G = G::from_u64(0); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_12: G = __b2_out[0]; + let __v_13: G = G::from_u64(256); + let __v_14: G = (__v_13 * __v_8); + let __v_15: G = G::from_u64(65536); + let __v_16: G = (__v_15 * __v_10); + let __v_17: G = G::from_u64(16777216); + let __v_18: G = (__v_17 * __v_12); + let __v_19: G = (__v_16 + __v_18); + let __v_20: G = (__v_14 + __v_19); + let __v_21: G = (__v_6 + __v_20); + if (__v_0 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(1); + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_375] = [__v_30]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_376: usize = 1; +const IN_376: usize = 1; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_376], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(65); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = result.output.try_into().unwrap(); __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __ret: [G; OUT_376] = [__v_2]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_377: usize = 2; +const IN_377: usize = 2; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_377], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_377] = [__v_1]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = result.output.try_into().unwrap(); __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = result.output.try_into().unwrap(); __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_377] = [__v_7]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_378: usize = 2; +const IN_378: usize = 2; +const OUT_378: usize = 2; +fn aiur_fn_378( + inp: [G; IN_378], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_378], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(128); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_2]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_2)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_3: G = __b2_out[0]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_378] = [__v_0, __v_1]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(224); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_5: G = __b2_out[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(192); + let __v_10: G = (__v_0 - __v_9); + let __v_11: G = G::from_u64(64); + let __v_12: G = (__v_10 * __v_11); + let __v_13: G = G::from_u64(128); + let __v_14: G = (__v_7 - __v_13); + let __v_15: G = (__v_12 + __v_14); + let __ret: [G; OUT_378] = [__v_15, __v_8]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_6: G = G::from_u64(240); + let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; + let __v_7: G = __b2_out[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(224); + let __v_15: G = (__v_0 - __v_14); + let __v_16: G = G::from_u64(4096); + let __v_17: G = (__v_15 * __v_16); + let __v_18: G = G::from_u64(128); + let __v_19: G = (__v_9 - __v_18); + let __v_20: G = G::from_u64(64); + let __v_21: G = (__v_19 * __v_20); + let __v_22: G = G::from_u64(128); + let __v_23: G = (__v_12 - __v_22); + let __v_24: G = (__v_21 + __v_23); + let __v_25: G = (__v_17 + __v_24); + let __ret: [G; OUT_378] = [__v_25, __v_13]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(240); + let __v_18: G = (__v_0 - __v_17); + let __v_19: G = G::from_u64(262144); + let __v_20: G = (__v_18 * __v_19); + let __v_21: G = G::from_u64(128); + let __v_22: G = (__v_9 - __v_21); + let __v_23: G = G::from_u64(4096); + let __v_24: G = (__v_22 * __v_23); + let __v_25: G = G::from_u64(128); + let __v_26: G = (__v_12 - __v_25); + let __v_27: G = G::from_u64(64); + let __v_28: G = (__v_26 * __v_27); + let __v_29: G = G::from_u64(128); + let __v_30: G = (__v_15 - __v_29); + let __v_31: G = (__v_28 + __v_30); + let __v_32: G = (__v_24 + __v_31); + let __v_33: G = (__v_20 + __v_32); + let __ret: [G; OUT_378] = [__v_33, __v_16]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_379: usize = 2; +const IN_379: usize = 2; +const OUT_379: usize = 2; +fn aiur_fn_379( + inp: [G; IN_379], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_379], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = result.output.try_into().unwrap(); __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_6, __v_10]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = result.output.try_into().unwrap(); __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_10, __v_14]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = result.output.try_into().unwrap(); __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_14, __v_18]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_14, __v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_18, __v_22]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = result.output.try_into().unwrap(); __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_18, __v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_22, __v_26]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_25, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = G::from_u64(2); + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_5, __v_29, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(2); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_9, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(2); + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(1); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_13, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = G::from_u64(2); + let __v_43: G = G::from_u64(1); + let __v_44: G = G::from_u64(1); + let __v_45: G = { let __values: [G; 3] = [__v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 4] = [__v_42, __v_17, __v_45, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = G::from_u64(2); + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_21, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = G::from_u64(3); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_32, __v_41, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = G::from_u64(3); + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_35, __v_41, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_56, __v_59, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = result.output.try_into().unwrap(); __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(1); + let __v_62: G = G::from_u64(3); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_62, __v_53, __v_60, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_61, __v_64]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_380: usize = 4; +const IN_380: usize = 4; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_380], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_380] = [__v_1]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = result.output.try_into().unwrap(); __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = result.output.try_into().unwrap(); __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(7); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(3); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(3); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = result.output.try_into().unwrap(); __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(3); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_380] = [__v_23]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_381: usize = 2; +const IN_381: usize = 2; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_381], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + match __v_3.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = result.output.try_into().unwrap(); __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_382: usize = 3; +const IN_382: usize = 3; +const OUT_382: usize = 2; +fn aiur_fn_382( + inp: [G; IN_382], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_382], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = result.output.try_into().unwrap(); __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_22.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_382] = [__v_23, __v_27]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(8); + let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_382] = [__v_27, __v_28]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_382] = [__v_21, __v_25]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_382] = [__v_15, __v_19]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_383: usize = 5; +const IN_383: usize = 5; +const OUT_383: usize = 2; +fn aiur_fn_383( + inp: [G; IN_383], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_383], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = result.output.try_into().unwrap(); __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_8, __v_12]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = result.output.try_into().unwrap(); __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_15, __v_19]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(5); + let __v_17: G = { let __a_val = __v_15.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_18, __v_22]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(4); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + let __v_31: G = __loaded[3]; + match __v_28.as_canonical_u64() { + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + match __v_32.as_canonical_u64() { + 4u64 => { + let __v_36: G = G::from_u64(8); + let __v_37: G = { let __values: [G; 4] = [__v_36, __v_0, __v_1, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(4); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_33, __v_37, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_41: G = __loaded[0]; + let __v_42: G = __loaded[1]; + let __v_43: G = __loaded[2]; + let __v_44: G = __loaded[3]; + match __v_41.as_canonical_u64() { + 4u64 => { + let __v_45: G = G::from_u64(8); + let __v_46: G = { let __values: [G; 4] = [__v_45, __v_0, __v_1, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = G::from_u64(4); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_42, __v_46, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_50, __v_4, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = __r_arr[1]; + match __v_52.as_canonical_u64() { + 1u64 => { + let __v_54: G = G::from_u64(2); + let __v_55: G = G::from_u64(1); + let __v_56: G = G::from_u64(1); + let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_54, __v_53, __v_57, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = G::from_u64(4); + let __v_61: G = G::from_u64(0); + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_29, __v_59, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = G::from_u64(2); + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_9, __v_10, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(3); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_19, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_62, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(3); + let __v_73: G = G::from_u64(0); + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_40, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = G::from_u64(3); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 4] = [__v_75, __v_74, __v_49, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = G::from_u64(3); + let __v_79: G = G::from_u64(0); + let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = G::from_u64(5); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __v_83: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_80, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __ret: [G; OUT_383] = [__v_83, __v_84]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_54, __v_58]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); + }, + } + }, + _ => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_45, __v_49]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_36, __v_40]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_32, __v_36]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_12, __v_16]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_8, __v_12]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_384: usize = 2; +const IN_384: usize = 2; +const OUT_384: usize = 5; +fn aiur_fn_384( + inp: [G; IN_384], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_384], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 4u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = result.output.try_into().unwrap(); __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = __r_arr[3]; + let __v_12: G = __r_arr[4]; + let __ret: [G; OUT_384] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 - __v_12); + let __v_14: G = (__v_13 - __v_7); + let __ret: [G; OUT_384] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_10, __v_11, __v_12, __v_13, __v_14]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_385: usize = 1; +const IN_385: usize = 1; +const OUT_385: usize = 1; +fn aiur_fn_385( + inp: [G; IN_385], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_385], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_2 + __v_5); + let __ret: [G; OUT_385] = [__v_6]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_7]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_8]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_8]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = result.output.try_into().unwrap(); __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_386: usize = 3; +const IN_386: usize = 3; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: [G; IN_386], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_386], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_386] = [__v_8]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_387: usize = 2; +const IN_387: usize = 2; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_387], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_387] = [__v_1]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_387] = [__v_0]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_388: usize = 1; +const IN_388: usize = 1; +const OUT_388: usize = 1; +fn aiur_fn_388( + inp: [G; IN_388], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_388], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_388] = [__v_1]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_1: G = G::from_u64(1); + let __v_2: G = (__v_0 - __v_1); + let __ret: [G; OUT_388] = [__v_2]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_389: usize = 2; +const IN_389: usize = 2; +const OUT_389: usize = 1; +fn aiur_fn_389( + inp: [G; IN_389], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_389], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_389] = [__v_0]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_389] = [__v_1]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_390: usize = 2; +const IN_390: usize = 2; +const OUT_390: usize = 1; +fn aiur_fn_390( + inp: [G; IN_390], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_390], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = result.output.try_into().unwrap(); __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = result.output.try_into().unwrap(); __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_390] = [__v_4]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_391: usize = 3; +const IN_391: usize = 3; +const OUT_391: usize = 1; +fn aiur_fn_391( + inp: [G; IN_391], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_391], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = result.output.try_into().unwrap(); __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = result.output.try_into().unwrap(); __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = result.output.try_into().unwrap(); __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_391] = [__v_7]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_391] = [__v_2]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_392: usize = 4; +const IN_392: usize = 4; +const OUT_392: usize = 1; +fn aiur_fn_392( + inp: [G; IN_392], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_392], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_392] = [__v_3]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_2 + __v_5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_6 + __v_8); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = result.output.try_into().unwrap(); __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_392] = [__v_13]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_393: usize = 2; +const IN_393: usize = 2; +const OUT_393: usize = 1; +fn aiur_fn_393( + inp: [G; IN_393], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_393], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_393] = [__v_4]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_393] = [__v_0]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = result.output.try_into().unwrap(); __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_393] = [__v_5]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_394: usize = 3; +const IN_394: usize = 3; +const OUT_394: usize = 1; +fn aiur_fn_394( + inp: [G; IN_394], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_394], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_394] = [__v_0]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_394] = [__v_0]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = result.output.try_into().unwrap(); __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_394] = [__v_5]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_395: usize = 3; +const IN_395: usize = 3; +const OUT_395: usize = 1; +fn aiur_fn_395( + inp: [G; IN_395], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_395], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_395] = [__v_0]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = (__v_4 + __v_1); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_11]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_11]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_7: G = G::from_u64(7); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_396: usize = 3; +const IN_396: usize = 3; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_396], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_396] = [__v_0]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = result.output.try_into().unwrap(); __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_396] = [__v_5]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_397: usize = 3; +const IN_397: usize = 3; +const OUT_397: usize = 1; +fn aiur_fn_397( + inp: [G; IN_397], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_397], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_397] = [__v_0]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = (__v_4 - __v_2); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_397] = [__v_10]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_4 - __v_10); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_9, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_11]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_7: G = G::from_u64(7); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_398: usize = 3; +const IN_398: usize = 3; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_398], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_398] = [__v_0]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = result.output.try_into().unwrap(); __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_398] = [__v_5]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_399: usize = 3; +const IN_399: usize = 3; +const OUT_399: usize = 1; +fn aiur_fn_399( + inp: [G; IN_399], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_399], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_399] = [__v_6]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = (__v_2 + __v_4); + let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = (__v_0 - __v_2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_399] = [__v_10]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = (__v_0 - __v_4); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_399] = [__v_10]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_400: usize = 3; +const IN_400: usize = 3; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_400], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = result.output.try_into().unwrap(); __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_400] = [__v_7]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_11]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_13]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_13]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_13]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_7: G = G::from_u64(7); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_401: usize = 2; +const IN_401: usize = 2; +const OUT_401: usize = 1; +fn aiur_fn_401( + inp: [G; IN_401], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_401], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_401] = [__v_0]; + record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(3); + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_401] = [__v_8]; + record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_402: usize = 3; +const IN_402: usize = 3; +const OUT_402: usize = 3; +fn aiur_fn_402( + inp: [G; IN_402], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_402], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 4u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_9, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __ret: [G; OUT_402] = [__v_12, __v_13, __v_14]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_402] = [__v_0, __v_2, __v_1]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_402] = [__v_0, __v_2, __v_1]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_403: usize = 5; +const IN_403: usize = 5; +const OUT_403: usize = 1; +fn aiur_fn_403( + inp: [G; IN_403], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_403], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_12]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_16]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_14]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_404: usize = 5; +const IN_404: usize = 5; +const OUT_404: usize = 1; +fn aiur_fn_404( + inp: [G; IN_404], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_404], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_12]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = result.output.try_into().unwrap(); __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = result.output.try_into().unwrap(); __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_11]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = result.output.try_into().unwrap(); __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_405: usize = 7; +const IN_405: usize = 7; +const OUT_405: usize = 1; +fn aiur_fn_405( + inp: [G; IN_405], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_405], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = result.output.try_into().unwrap(); __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_12]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __v_28: G = (__v_22 + __v_1); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_30]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(8); + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_30]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(8); + let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_18]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_406: usize = 5; +const IN_406: usize = 5; +const OUT_406: usize = 2; +fn aiur_fn_406( + inp: [G; IN_406], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_406], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_13 + __v_15); + let __v_17: G = (__v_11 + __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_18, __v_22]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 2u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_23, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_27, __v_31]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = (__v_16 * __v_29); + let __v_31: G = (__v_27 + __v_30); + match __v_31.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + match __v_32.as_canonical_u64() { + 1u64 => { + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_35, __v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_34, __v_38]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_34: G = G::from_u64(1); + let __v_35: G = G::from_u64(3); + let __v_36: G = G::from_u64(3); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_36, __v_0, __v_21, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_35, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_34, __v_41]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_32, __v_36]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_19, __v_23]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_9, __v_13]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_407: usize = 7; +const IN_407: usize = 7; +const OUT_407: usize = 2; +fn aiur_fn_407( + inp: [G; IN_407], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_407], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = result.output.try_into().unwrap(); __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_9, __v_8]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = result.output.try_into().unwrap(); __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_11, __v_10]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = result.output.try_into().unwrap(); __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_13, __v_12]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = result.output.try_into().unwrap(); __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_15, __v_14]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = result.output.try_into().unwrap(); __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_17, __v_16]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_407] = [__v_17, __v_21]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_408: usize = 7; +const IN_408: usize = 7; +const OUT_408: usize = 1; +fn aiur_fn_408( + inp: [G; IN_408], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_408], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = result.output.try_into().unwrap(); __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = result.output.try_into().unwrap(); __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = result.output.try_into().unwrap(); __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = result.output.try_into().unwrap(); __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_21, __v_25]; + }, +} + }; + let __v_21: G = __mc_out___mc_0[0]; + let __v_22: G = __mc_out___mc_0[1]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_23]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = result.output.try_into().unwrap(); __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = result.output.try_into().unwrap(); __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_408] = [__v_26]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_27, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_28]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_409: usize = 4; +const IN_409: usize = 4; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: [G; IN_409], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_409], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = result.output.try_into().unwrap(); __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_409] = [__v_10]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_410: usize = 4; +const IN_410: usize = 4; +const OUT_410: usize = 1; +fn aiur_fn_410( + inp: [G; IN_410], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_410], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_410] = [__v_6]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_411: usize = 5; +const IN_411: usize = 5; +const OUT_411: usize = 1; +fn aiur_fn_411( + inp: [G; IN_411], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_411], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_12]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = result.output.try_into().unwrap(); __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = result.output.try_into().unwrap(); __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_11]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = result.output.try_into().unwrap(); __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_412: usize = 5; +const IN_412: usize = 5; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_412], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_12]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_16]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_14]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_413: usize = 7; +const IN_413: usize = 7; +const OUT_413: usize = 1; +fn aiur_fn_413( + inp: [G; IN_413], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_413], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = result.output.try_into().unwrap(); __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_12]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __v_28: G = (__v_22 + __v_1); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_30]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(8); + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_30]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(8); + let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_18]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_414: usize = 7; +const IN_414: usize = 7; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_414], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = result.output.try_into().unwrap(); __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = result.output.try_into().unwrap(); __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = result.output.try_into().unwrap(); __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = result.output.try_into().unwrap(); __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_21, __v_25]; + }, +} + }; + let __v_21: G = __mc_out___mc_0[0]; + let __v_22: G = __mc_out___mc_0[1]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_23]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = result.output.try_into().unwrap(); __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_25]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_25]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_415: usize = 4; +const IN_415: usize = 4; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_415], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = result.output.try_into().unwrap(); __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_415] = [__v_10]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_416: usize = 4; +const IN_416: usize = 4; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_416], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_416] = [__v_6]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_417: usize = 12; +const IN_417: usize = 12; +const OUT_417: usize = 2; +fn aiur_fn_417( + inp: [G; IN_417], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_417], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = (__v_6 + __v_4); + let __v_13: G = (__v_5 + __v_12); + let __v_14: G = (__v_3 + __v_13); + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_417] = [__v_17, __v_21]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_17 - __v_2); + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_1, __v_3, __v_5, __v_6, __v_14, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = result.output.try_into().unwrap(); __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_417] = [__v_19, __v_20]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_417] = [__v_19, __v_23]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_418: usize = 2; +const IN_418: usize = 2; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: [G; IN_418], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_418], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = result.output.try_into().unwrap(); __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_13, __v_15, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = result.output.try_into().unwrap(); __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_418] = [__v_17]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_419: usize = 3; +const IN_419: usize = 3; +const OUT_419: usize = 3; +fn aiur_fn_419( + inp: [G; IN_419], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_419], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_10, __v_0, __v_13]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_10 - __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 7u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_419] = [__v_21, __v_14, __v_19]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_21, __v_0, __v_24]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_21, __v_0, __v_24]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_13, __v_0, __v_16]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_7, __v_0, __v_10]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_420: usize = 3; +const IN_420: usize = 3; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_420], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_0, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_420] = [__v_9]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 10] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + match __v_28.as_canonical_u64() { + 1u64 => { + let __v_29: G = G::from_u64(3); + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 4] = [__v_29, __v_27, __v_0, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_420] = [__v_31]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_29, __v_2, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __v_33: G = G::from_u64(3); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_27, __v_0, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_420] = [__v_35]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_33: G = G::from_u64(2); + let __v_34: G = G::from_u64(1); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_33, __v_32, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(7); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = { let __values: [G; 4] = [__v_39, __v_40, __v_21, __v_41]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = G::from_u64(3); + let __v_44: G = G::from_u64(3); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_38, __v_0, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = G::from_u64(0); + let __v_48: G = { let __values: [G; 4] = [__v_43, __v_46, __v_42, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = G::from_u64(3); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_49, __v_27, __v_48, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_420] = [__v_51]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_421: usize = 11; +const IN_421: usize = 11; +const OUT_421: usize = 2; +fn aiur_fn_421( + inp: [G; IN_421], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_421], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = result.output.try_into().unwrap(); __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_421] = [__v_13, __v_12]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = result.output.try_into().unwrap(); __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 1u64 => { + break '__mc_0 [__v_15]; + }, + 0u64 => { + break '__mc_0 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + break '__mc_0 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, +} + }; + let __v_14: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = result.output.try_into().unwrap(); __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_15, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_16, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = result.output.try_into().unwrap(); __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_17, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = result.output.try_into().unwrap(); __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_18, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = result.output.try_into().unwrap(); __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_22: G = __loaded[0]; + let __v_23: G = __loaded[1]; + let __v_24: G = __loaded[2]; + let __v_25: G = __loaded[3]; + match __v_22.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_27: G = __loaded[0]; + let __v_28: G = __loaded[1]; + let __v_29: G = __loaded[2]; + let __v_30: G = __loaded[3]; + let __v_31: G = __loaded[4]; + let __v_32: G = __loaded[5]; + let __v_33: G = __loaded[6]; + let __v_34: G = __loaded[7]; + let __v_35: G = __loaded[8]; + let __v_36: G = __loaded[9]; + let __v_37: G = __loaded[10]; + match __v_27.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_39.as_canonical_u64() { + 0u64 => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_421] = [__v_40, __v_44]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = { let __a_val = __v_40.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_41.as_canonical_u64() { + 1u64 => { + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_421] = [__v_42, __v_46]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_6, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = result.output.try_into().unwrap(); __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + match __v_42.as_canonical_u64() { + _ => { + let __v_45: G = (__v_3 + __v_4); + let __v_46: G = (__v_2 + __v_45); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_1, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = (__v_40 - __v_33); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_21, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_5 + __v_50); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_44, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_53, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_54, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = G::from_u64(1); + let __ret: [G; OUT_421] = [__v_57, __v_56]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_41.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_39.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = result.output.try_into().unwrap(); __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __ret: [G; OUT_421] = [__v_38, __v_39]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = result.output.try_into().unwrap(); __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_421] = [__v_26, __v_27]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_422: usize = 8; +const IN_422: usize = 8; +const OUT_422: usize = 2; +fn aiur_fn_422( + inp: [G; IN_422], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_422], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = G::from_u64(2); + let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_10, __v_14]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_11, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_14, __v_18]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_14: G = (__v_1 + __v_2); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_14 + __v_15); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_18, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = result.output.try_into().unwrap(); __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_20, __v_24]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_4 + __v_22); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 1u64 => { + let __v_28: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_28, __v_29]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_28, __v_7, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_32, __v_36]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_32: G = G::from_u64(2); + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 4] = [__v_32, __v_31, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(3); + let __v_39: G = G::from_u64(3); + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_39, __v_37, __v_21, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_38, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_45, __v_46]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_26, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_27, __v_30]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_423: usize = 2; +const IN_423: usize = 2; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: [G; IN_423], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_423], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_19]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(1); + let __v_21: G = (__v_19 - __v_20); + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + match __v_24.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_bool((__v_25 == G::ZERO)); + let __ret: [G; OUT_423] = [__v_28]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_28]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_22]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_16]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_10]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_6]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_424: usize = 10; +const IN_424: usize = 10; +const OUT_424: usize = 2; +fn aiur_fn_424( + inp: [G; IN_424], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_424], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = result.output.try_into().unwrap(); __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + match __v_12.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __v_19: G = __loaded[3]; + let __v_20: G = __loaded[4]; + let __v_21: G = __loaded[5]; + let __v_22: G = __loaded[6]; + let __v_23: G = __loaded[7]; + let __v_24: G = __loaded[8]; + let __v_25: G = __loaded[9]; + let __v_26: G = __loaded[10]; + match __v_16.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + let __v_31: G = __loaded[3]; + let __v_32: G = __loaded[4]; + let __v_33: G = __loaded[5]; + let __v_34: G = __loaded[6]; + let __v_35: G = __loaded[7]; + let __v_36: G = __loaded[8]; + let __v_37: G = __loaded[9]; + let __v_38: G = __loaded[10]; + match __v_28.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + match __v_39.as_canonical_u64() { + 1u64 => { + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_34.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_41, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = result.output.try_into().unwrap(); __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + match __v_42.as_canonical_u64() { + 1u64 => { + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_43, __v_47]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_14, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = (__v_1 + __v_2); + let __v_45: G = (__v_44 + __v_3); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_43, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_47, __v_19, __v_40, __v_13, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = result.output.try_into().unwrap(); __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_4 + __v_50); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = G::from_u64(1); + let __ret: [G; OUT_424] = [__v_54, __v_53]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64())); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_11, __v_15]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_425: usize = 5; +const IN_425: usize = 5; +const OUT_425: usize = 2; +fn aiur_fn_425( + inp: [G; IN_425], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_425], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_0.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = result.output.try_into().unwrap(); __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_425] = [__v_5, __v_6]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = result.output.try_into().unwrap(); __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_425] = [__v_5, __v_6]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_425] = [__v_5, __v_9]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_426: usize = 4; +const IN_426: usize = 4; +const OUT_426: usize = 2; +fn aiur_fn_426( + inp: [G; IN_426], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_426], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(6); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_426] = [__v_7, __v_11]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = result.output.try_into().unwrap(); __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(6); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_426] = [__v_19, __v_18]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_426] = [__v_13, __v_17]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_427: usize = 4; +const IN_427: usize = 4; +const OUT_427: usize = 2; +fn aiur_fn_427( + inp: [G; IN_427], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_427], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(5); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_427] = [__v_7, __v_11]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(4); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = result.output.try_into().unwrap(); __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(5); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_427] = [__v_19, __v_18]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_427] = [__v_13, __v_17]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_428: usize = 4; +const IN_428: usize = 4; +const OUT_428: usize = 2; +fn aiur_fn_428( + inp: [G; IN_428], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_428], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + match __v_12.as_canonical_u64() { + 4u64 => { + match __v_15.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(3); + let __v_25: G = (__v_23 - __v_24); + match __v_25.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(1); + let __ret: [G; OUT_428] = [__v_28, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_428] = [__v_26, __v_30]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_428] = [__v_23, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_428] = [__v_23, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_428] = [__v_11, __v_15]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_429: usize = 5; +const IN_429: usize = 5; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: [G; IN_429], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_429], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_3 - __v_4); + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(8); + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_4 + __v_11); + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = result.output.try_into().unwrap(); __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_429] = [__v_13]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_430: usize = 6; +const IN_430: usize = 6; +const OUT_430: usize = 2; +fn aiur_fn_430( + inp: [G; IN_430], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_430], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_11, __v_15]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + match __v_12.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + match __v_35.as_canonical_u64() { + 0u64 => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_36, __v_40]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_42: G = __loaded[0]; + let __v_43: G = __loaded[1]; + let __v_44: G = __loaded[2]; + let __v_45: G = __loaded[3]; + match __v_42.as_canonical_u64() { + 2u64 => { + let __v_46: G = (__v_43 - __v_15); + match __v_46.as_canonical_u64() { + 0u64 => { + let __v_47: G = G::from_u64(2); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_41, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_51, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + match __v_53.as_canonical_u64() { + 1u64 => { + let __v_54: G = G::from_u64(1); + let __ret: [G; OUT_430] = [__v_54, __v_51]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_54, __v_58]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_48, __v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_47, __v_51]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_46, __v_50]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_431: usize = 2; +const IN_431: usize = 2; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_431], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_431] = [__v_8]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_431] = [__v_3]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_432: usize = 1; +const IN_432: usize = 1; +const OUT_432: usize = 2; +fn aiur_fn_432( + inp: [G; IN_432], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_432], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_432] = [__v_5, __v_2]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_432] = [__v_5, __v_8]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_433: usize = 1; +const IN_433: usize = 1; +const OUT_433: usize = 3; +fn aiur_fn_433( + inp: [G; IN_433], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_433], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 5u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_433] = [__v_5, __v_2, __v_3]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_433] = [__v_5, __v_9, __v_13]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_434: usize = 2; +const IN_434: usize = 2; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: [G; IN_434], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_434], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_434] = [__v_8]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_434] = [__v_7]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_434] = [__v_10]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_435: usize = 4; +const IN_435: usize = 4; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: [G; IN_435], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_435], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = result.output.try_into().unwrap(); __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_435] = [__v_6]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_436: usize = 4; +const IN_436: usize = 4; +const OUT_436: usize = 1; +fn aiur_fn_436( + inp: [G; IN_436], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_436], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_8, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_436] = [__v_16]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + if (__v_21 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_23]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_14]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(5); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_5, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_436] = [__v_14]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_12, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_436] = [__v_24]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_11]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = result.output.try_into().unwrap(); __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = result.output.try_into().unwrap(); __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 8u64 => { + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + if (__v_13 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + if (__v_28 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + let __v_30: G = (__v_20 + __v_21); + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = result.output.try_into().unwrap(); __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + match __v_35.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_49]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_437: usize = 6; +const IN_437: usize = 6; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: [G; IN_437], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_437], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_10]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_10, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_17]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = result.output.try_into().unwrap(); __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = G::from_u64(1); + if (__v_16 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_17, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(1); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_20, __v_7, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_25]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_438: usize = 4; +const IN_438: usize = 4; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: [G; IN_438], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_438], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_438] = [__v_6]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = result.output.try_into().unwrap(); __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = G::from_u64(1); + if (__v_10 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_438] = [__v_11]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_439: usize = 5; +const IN_439: usize = 5; +const OUT_439: usize = 0; +fn aiur_fn_439( + inp: [G; IN_439], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_439], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + if (__v_6 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + let __ret: [G; OUT_439] = []; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_440: usize = 4; +const IN_440: usize = 4; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: [G; IN_440], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_440], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = result.output.try_into().unwrap(); __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_440] = [__v_6]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_441: usize = 4; +const IN_441: usize = 4; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_441], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_8, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_441] = [__v_16]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + if (__v_21 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_23]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_6, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_14]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = result.output.try_into().unwrap(); __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(1); + if (__v_14 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_16, __v_6, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_19]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(5); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_441] = [__v_13]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = result.output.try_into().unwrap(); __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = result.output.try_into().unwrap(); __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_12, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_441] = [__v_24]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_10]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = result.output.try_into().unwrap(); __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = result.output.try_into().unwrap(); __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 8u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + if (__v_13 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + if (__v_28 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + let __v_30: G = (__v_20 + __v_21); + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = result.output.try_into().unwrap(); __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + match __v_35.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_49]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_442: usize = 4; +const IN_442: usize = 4; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_442], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = result.output.try_into().unwrap(); __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = G::from_u64(1); + if (__v_10 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_442] = [__v_11]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_443: usize = 11; +const IN_443: usize = 11; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: [G; IN_443], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_443], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_444: usize = 11; +const IN_444: usize = 11; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_444], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_445: usize = 3; +const IN_445: usize = 3; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: [G; IN_445], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_445], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_445] = [__v_0]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_8, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_2 - __v_12); + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_11, __v_9, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_445] = [__v_14]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_446: usize = 9; +const IN_446: usize = 9; +const OUT_446: usize = 1; +fn aiur_fn_446( + inp: [G; IN_446], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_446], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = (__v_1 - __v_2); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = result.output.try_into().unwrap(); __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_446] = [__v_10]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = result.output.try_into().unwrap(); __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __v_14: G = G::from_u64(8); + let __v_15: G = { let __values: [G; 4] = [__v_14, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 + __v_18); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_17, __v_1, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_446] = [__v_20]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_447: usize = 6; +const IN_447: usize = 6; +const OUT_447: usize = 0; +fn aiur_fn_447( + inp: [G; IN_447], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_447], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + if (__v_13 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_448: usize = 5; +const IN_448: usize = 5; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_448], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_448] = [__v_5]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_1 - __v_10); + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_8, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = result.output.try_into().unwrap(); __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_448] = [__v_12]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_448] = [__v_5]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_449: usize = 6; +const IN_449: usize = 6; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_449], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = result.output.try_into().unwrap(); __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_449] = [__v_17]; + record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_449] = [__v_12]; + record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_450: usize = 5; +const IN_450: usize = 5; +const OUT_450: usize = 0; +fn aiur_fn_450( + inp: [G; IN_450], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_450], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_450] = []; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_450] = []; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_451: usize = 1; +const IN_451: usize = 1; +const OUT_451: usize = 1; +fn aiur_fn_451( + inp: [G; IN_451], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_451], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_451] = [__v_9]; + record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_452: usize = 1; +const IN_452: usize = 1; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_452], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = result.output.try_into().unwrap(); __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_452] = [__v_9]; + record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_453: usize = 3; +const IN_453: usize = 3; +const OUT_453: usize = 1; +fn aiur_fn_453( + inp: [G; IN_453], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_453], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_453] = [__v_2]; + record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_453] = [__v_9]; + record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_454: usize = 5; +const IN_454: usize = 5; +const OUT_454: usize = 1; +fn aiur_fn_454( + inp: [G; IN_454], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_454], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_0 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_454] = [__v_6]; + record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = result.output.try_into().unwrap(); __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_454] = [__v_10]; + record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_455: usize = 5; +const IN_455: usize = 5; +const OUT_455: usize = 1; +fn aiur_fn_455( + inp: [G; IN_455], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_455], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = result.output.try_into().unwrap(); __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_6]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = result.output.try_into().unwrap(); __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_7]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_7 - __v_8); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_10]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = result.output.try_into().unwrap(); __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_11]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = result.output.try_into().unwrap(); __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_12]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = (__v_12 - __v_13); + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_15]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = result.output.try_into().unwrap(); __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_16]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = result.output.try_into().unwrap(); __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_17]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = result.output.try_into().unwrap(); __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_18]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_13, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = result.output.try_into().unwrap(); __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_19]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = result.output.try_into().unwrap(); __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_455] = [__v_20]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(16); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_455] = [__v_23]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = result.output.try_into().unwrap(); __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_455] = [__v_24]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_456: usize = 5; +const IN_456: usize = 5; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_456], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_19]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_16]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_14]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_16]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_14]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_9]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_457: usize = 5; +const IN_457: usize = 5; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_457], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = result.output.try_into().unwrap(); __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_457] = [__v_7]; + record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_457] = [__v_8]; + record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_458: usize = 4; +const IN_458: usize = 4; +const OUT_458: usize = 1; +fn aiur_fn_458( + inp: [G; IN_458], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_458], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_458] = [__v_13]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_13]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_10]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_459: usize = 5; +const IN_459: usize = 5; +const OUT_459: usize = 1; +fn aiur_fn_459( + inp: [G; IN_459], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_459], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = result.output.try_into().unwrap(); __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_459] = [__v_8]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_459] = [__v_9]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_460: usize = 2; +const IN_460: usize = 2; +const OUT_460: usize = 1; +fn aiur_fn_460( + inp: [G; IN_460], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_460], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 5u64 => { + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_20]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 6u64 => { + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_35: G = G::from_u64(1); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_21]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_20]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_8]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_461: usize = 5; +const IN_461: usize = 5; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: [G; IN_461], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_461], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = result.output.try_into().unwrap(); __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_461] = [__v_6]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = result.output.try_into().unwrap(); __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_461] = [__v_6]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_462: usize = 5; +const IN_462: usize = 5; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_462], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 7u64 => { + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_7, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = result.output.try_into().unwrap(); __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_462] = [__v_11]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_11]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_9]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_9]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_463: usize = 2; +const IN_463: usize = 2; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: [G; IN_463], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_463], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_463] = [__v_8]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_464: usize = 2; +const IN_464: usize = 2; +const OUT_464: usize = 3; +fn aiur_fn_464( + inp: [G; IN_464], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_464], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_6, __v_10, __v_4]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_6, __v_0, __v_9]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_16, __v_14, __v_17]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_13, __v_0, __v_16]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 7u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __v_24: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_23, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_24, __v_22, __v_25]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_24: G = G::from_u64(1); + let __ret: [G; OUT_464] = [__v_24, __v_8, __v_19]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_21, __v_0, __v_24]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_21, __v_0, __v_24]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_17, __v_0, __v_20]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_14, __v_0, __v_17]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_10, __v_0, __v_13]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_6, __v_0, __v_9]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_465: usize = 5; +const IN_465: usize = 5; +const OUT_465: usize = 2; +fn aiur_fn_465( + inp: [G; IN_465], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_465], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = result.output.try_into().unwrap(); __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = result.output.try_into().unwrap(); __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_5 * __v_6); + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_465] = [__v_8, __v_9]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = (__v_8 * __v_11); + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_15, __v_16]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_16, __v_17]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_9, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_465] = [__v_16, __v_17]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_466: usize = 5; +const IN_466: usize = 5; +const OUT_466: usize = 1; +fn aiur_fn_466( + inp: [G; IN_466], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_466], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + match __v_12.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = (__v_17 + __v_18); + let __v_25: G = (__v_23 - __v_24); + match __v_25.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_27: G = __loaded[0]; + let __v_28: G = __loaded[1]; + let __v_29: G = __loaded[2]; + let __v_30: G = __loaded[3]; + let __v_31: G = __loaded[4]; + let __v_32: G = __loaded[5]; + let __v_33: G = __loaded[6]; + let __v_34: G = __loaded[7]; + let __v_35: G = __loaded[8]; + let __v_36: G = __loaded[9]; + let __v_37: G = __loaded[10]; + match __v_27.as_canonical_u64() { + 5u64 => { + let __v_38: G = G::from_bool((__v_33 == G::ZERO)); + let __v_39: G = G::from_bool((__v_31 == G::ZERO)); + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(1); + let __v_42: G = (__v_40 - __v_41); + let __v_43: G = G::from_bool((__v_42 == G::ZERO)); + let __v_44: G = (__v_39 * __v_43); + let __v_45: G = (__v_38 * __v_44); + match __v_45.as_canonical_u64() { + 0u64 => { + let __v_46: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_46]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_46: G = G::from_u64(0); + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_46, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = result.output.try_into().unwrap(); __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __ret: [G; OUT_466] = [__v_47]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_38]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_26]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_23]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_11]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_467: usize = 9; +const IN_467: usize = 9; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_467], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = (__v_2 - __v_5); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_467] = [__v_10]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(8); + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = (__v_1 + __v_5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_11, __v_13, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_467] = [__v_15]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_5 + __v_15); + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_16, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = result.output.try_into().unwrap(); __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_467] = [__v_17]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_468: usize = 5; +const IN_468: usize = 5; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_468], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_19]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_6 - __v_10); + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __v_13: G = (__v_6 - __v_10); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_16]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_16]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_16, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_17]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_15]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = result.output.try_into().unwrap(); __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 8u64 => { + let __v_13: G = (__v_6 - __v_10); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __v_15: G = (__v_7 - __v_11); + let __v_16: G = G::from_bool((__v_15 == G::ZERO)); + let __v_17: G = (__v_14 * __v_16); + match __v_17.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_18]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_18]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_469: usize = 6; +const IN_469: usize = 6; +const OUT_469: usize = 1; +fn aiur_fn_469( + inp: [G; IN_469], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_469], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(3); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_469] = [__v_18]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_470: usize = 2; +const IN_470: usize = 2; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: [G; IN_470], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_470], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_470] = [__v_15]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_15]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_471: usize = 5; +const IN_471: usize = 5; +const OUT_471: usize = 1; +fn aiur_fn_471( + inp: [G; IN_471], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_471], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + match __v_13.as_canonical_u64() { + 2u64 => { + let __v_17: G = (__v_10 - __v_14); + match __v_17.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_11, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_19]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = (__v_19 - __v_20); + match __v_21.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_471] = [__v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_18]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_17]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_13]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_472: usize = 5; +const IN_472: usize = 5; +const OUT_472: usize = 1; +fn aiur_fn_472( + inp: [G; IN_472], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_472], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_12]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_472] = [__v_12]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_473: usize = 2; +const IN_473: usize = 2; +const OUT_473: usize = 1; +fn aiur_fn_473( + inp: [G; IN_473], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_473], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_474: usize = 2; +const IN_474: usize = 2; +const OUT_474: usize = 1; +fn aiur_fn_474( + inp: [G; IN_474], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_474], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_474] = [__v_8]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_474] = [__v_14]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_475: usize = 2; +const IN_475: usize = 2; +const OUT_475: usize = 2; +fn aiur_fn_475( + inp: [G; IN_475], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_475], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_475] = [__v_21, __v_22]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_475] = [__v_21, __v_22]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_475] = [__v_20, __v_0]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_475] = [__v_8, __v_0]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_476: usize = 2; +const IN_476: usize = 2; +const OUT_476: usize = 2; +fn aiur_fn_476( + inp: [G; IN_476], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_476], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(8); + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_5, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_476] = [__v_12, __v_13]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_476] = [__v_10, __v_0]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_476] = [__v_8, __v_0]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_477: usize = 6; +const IN_477: usize = 6; +const OUT_477: usize = 2; +fn aiur_fn_477( + inp: [G; IN_477], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_477], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_477] = [__v_6, __v_7]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = (__v_0 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_477] = [__v_7, __v_8]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 2u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __v_18: G = __loaded[3]; + match __v_15.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_12, __v_13, __v_8, __v_16, __v_17, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = result.output.try_into().unwrap(); __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_477] = [__v_20, __v_21]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = result.output.try_into().unwrap(); __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_20, __v_21]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = result.output.try_into().unwrap(); __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __v_18: G = __loaded[3]; + match __v_15.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = result.output.try_into().unwrap(); __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_478: usize = 9; +const IN_478: usize = 9; +const OUT_478: usize = 1; +fn aiur_fn_478( + inp: [G; IN_478], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_478], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = (__v_0 - __v_3); + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_11]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = (__v_11 - __v_12); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_478] = [__v_14]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_14]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_10]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_479: usize = 8; +const IN_479: usize = 8; +const OUT_479: usize = 2; +fn aiur_fn_479( + inp: [G; IN_479], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_479], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = result.output.try_into().unwrap(); __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = result.output.try_into().unwrap(); __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_13, __v_14]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_14, __v_15]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = result.output.try_into().unwrap(); __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_14, __v_15]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_480: usize = 7; +const IN_480: usize = 7; +const OUT_480: usize = 2; +fn aiur_fn_480( + inp: [G; IN_480], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_480], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_480] = [__v_8, __v_9]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = result.output.try_into().unwrap(); __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 - __v_11); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_480] = [__v_13, __v_14]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_480] = [__v_10, __v_11]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_480] = [__v_8, __v_9]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_481: usize = 7; +const IN_481: usize = 7; +const OUT_481: usize = 2; +fn aiur_fn_481( + inp: [G; IN_481], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_481], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_481] = [__v_8, __v_9]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = result.output.try_into().unwrap(); __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 - __v_11); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_481] = [__v_13, __v_14]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_481] = [__v_10, __v_11]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_481] = [__v_8, __v_9]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_482: usize = 6; +const IN_482: usize = 6; +const OUT_482: usize = 2; +fn aiur_fn_482( + inp: [G; IN_482], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_482], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_482] = [__v_11, __v_12]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_482] = [__v_8, __v_9]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_483: usize = 6; +const IN_483: usize = 6; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_483], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_483] = [__v_11, __v_12]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_483] = [__v_8, __v_9]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_484: usize = 6; +const IN_484: usize = 6; +const OUT_484: usize = 2; +fn aiur_fn_484( + inp: [G; IN_484], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_484], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_2 - __v_12); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_484] = [__v_14, __v_15]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_484] = [__v_10, __v_11]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_484] = [__v_8, __v_9]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_485: usize = 6; +const IN_485: usize = 6; +const OUT_485: usize = 0; +fn aiur_fn_485( + inp: [G; IN_485], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_485], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = (__v_1 + __v_3); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 2u64 => { + if (__v_11 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = result.output.try_into().unwrap(); __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_1 + __v_2); + if (__v_15 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9, __v_1, __v_3, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = result.output.try_into().unwrap(); __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_485] = []; + record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_486: usize = 2; +const IN_486: usize = 2; +const OUT_486: usize = 1; +fn aiur_fn_486( + inp: [G; IN_486], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_486], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_486] = [__v_0]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_486] = [__v_8]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_487: usize = 3; +const IN_487: usize = 3; +const OUT_487: usize = 0; +fn aiur_fn_487( + inp: [G; IN_487], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_487], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(0); + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_487] = []; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 4u64 => { + if (__v_7 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 - __v_9); + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_2 + __v_11); + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_5, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = result.output.try_into().unwrap(); __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_487] = []; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_488: usize = 4; +const IN_488: usize = 4; +const OUT_488: usize = 0; +fn aiur_fn_488( + inp: [G; IN_488], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_488], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_488] = []; + record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_12: G = (__v_2 + __v_1); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_12 - __v_13); + let __v_15: G = (__v_14 - __v_3); + if (__v_9 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_3 + __v_16); + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = result.output.try_into().unwrap(); __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_488] = []; + record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_489: usize = 2; +const IN_489: usize = 2; +const OUT_489: usize = 3; +fn aiur_fn_489( + inp: [G; IN_489], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_489], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __ret: [G; OUT_489] = [__v_6, __v_7, __v_8]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __ret: [G; OUT_489] = [__v_8, __v_9, __v_10]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_490: usize = 8; +const IN_490: usize = 8; +const OUT_490: usize = 0; +fn aiur_fn_490( + inp: [G; IN_490], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_490], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_490] = []; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = result.output.try_into().unwrap(); __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_490] = []; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_491: usize = 8; +const IN_491: usize = 8; +const OUT_491: usize = 0; +fn aiur_fn_491( + inp: [G; IN_491], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_491], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = result.output.try_into().unwrap(); __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_491] = []; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 5u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_9, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_1 - __v_14); + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_10, __v_15, __v_2, __v_3, __v_4, __v_13, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = result.output.try_into().unwrap(); __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_491] = []; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_492: usize = 7; +const IN_492: usize = 7; +const OUT_492: usize = 0; +fn aiur_fn_492( + inp: [G; IN_492], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_492], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12, __v_13, __v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + if (__v_15 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 3] = [__v_17, __v_8, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_9, __v_1, __v_2, __v_3, __v_18, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = result.output.try_into().unwrap(); __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_492] = []; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_492] = []; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_493: usize = 6; +const IN_493: usize = 6; +const OUT_493: usize = 0; +fn aiur_fn_493( + inp: [G; IN_493], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_493], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_8, __v_7, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_493] = []; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_494: usize = 2; +const IN_494: usize = 2; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_494], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_494] = [__v_0]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_494] = [__v_0]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_495: usize = 3; +const IN_495: usize = 3; +const OUT_495: usize = 2; +fn aiur_fn_495( + inp: [G; IN_495], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_495], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_495] = [__v_0, __v_2]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 - __v_9); + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_10, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_495] = [__v_11, __v_12]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_495] = [__v_0, __v_2]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_496: usize = 5; +const IN_496: usize = 5; +const OUT_496: usize = 0; +fn aiur_fn_496( + inp: [G; IN_496], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_496], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = result.output.try_into().unwrap(); __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_1, __v_10, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_496] = []; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_496] = []; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_497: usize = 5; +const IN_497: usize = 5; +const OUT_497: usize = 0; +fn aiur_fn_497( + inp: [G; IN_497], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_497], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_9, __v_1, __v_14, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = result.output.try_into().unwrap(); __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + match __v_13.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + match __v_19.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_30, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + if (__v_31 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = result.output.try_into().unwrap(); __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_24, __v_12, __v_33, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(1); + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64() }); + } + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + if (__v_17 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_498], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_498] = [__v_5]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = (__v_3 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_498] = [__v_6]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_498] = [__v_6]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_499: usize = 4; +const IN_499: usize = 4; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: [G; IN_499], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_499], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_499] = [__v_7]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_19, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = result.output.try_into().unwrap(); __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_499] = [__v_19]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_500: usize = 2; +const IN_500: usize = 2; +const OUT_500: usize = 1; +fn aiur_fn_500( + inp: [G; IN_500], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_500], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = result.output.try_into().unwrap(); __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_500] = [__v_6]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_501: usize = 2; +const IN_501: usize = 2; +const OUT_501: usize = 1; +fn aiur_fn_501( + inp: [G; IN_501], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_501], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 7u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_502: usize = 2; +const IN_502: usize = 2; +const OUT_502: usize = 1; +fn aiur_fn_502( + inp: [G; IN_502], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_502], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_502] = [__v_5]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_503: usize = 3; +const IN_503: usize = 3; +const OUT_503: usize = 1; +fn aiur_fn_503( + inp: [G; IN_503], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_503], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_503] = [__v_4]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_504: usize = 4; +const IN_504: usize = 4; +const OUT_504: usize = 1; +fn aiur_fn_504( + inp: [G; IN_504], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_504], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_504] = [__v_0]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 32] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = (__v_19 - __v_53); + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_56 - __v_55); + let __v_58: G = (__v_54 * __v_57); + let __v_59: G = (__v_18 * __v_58); + match __v_59.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(1); + let __v_63: G = (__v_3 + __v_62); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_61, __v_1, __v_6, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_64]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_3 + __v_60); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_62]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_20]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_505: usize = 5; +const IN_505: usize = 5; +const OUT_505: usize = 0; +fn aiur_fn_505( + inp: [G; IN_505], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_505], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 6u64 => { + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_11, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_23, __v_2, __v_24, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_506: usize = 2; +const IN_506: usize = 2; +const OUT_506: usize = 1; +fn aiur_fn_506( + inp: [G; IN_506], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_506], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_6: G = (__v_3 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_10]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_507: usize = 6; +const IN_507: usize = 6; +const OUT_507: usize = 1; +fn aiur_fn_507( + inp: [G; IN_507], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_507], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_7]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_8]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + match __v_11.as_canonical_u64() { + 6u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_22]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_13, __v_16, __v_17, __v_24, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = result.output.try_into().unwrap(); __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_507] = [__v_25]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_507] = [__v_8]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_508: usize = 6; +const IN_508: usize = 6; +const OUT_508: usize = 1; +fn aiur_fn_508( + inp: [G; IN_508], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_508], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = result.output.try_into().unwrap(); __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 - __v_12); + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = result.output.try_into().unwrap(); __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_508] = [__v_14]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_509: usize = 7; +const IN_509: usize = 7; +const OUT_509: usize = 1; +fn aiur_fn_509( + inp: [G; IN_509], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_509], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = (__v_1 - __v_2); + match __v_7.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = result.output.try_into().unwrap(); __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_509] = [__v_10]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_13 - __v_19); + let __v_21: G = G::from_u64(1); + let __v_22: G = (__v_21 - __v_2); + let __v_23: G = (__v_1 - __v_22); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_6]; + }, + _ => { + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 3] = [__v_24, __v_23, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_25]; + }, +} + }; + let __v_24: G = __mc_out___mc_0[0]; + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 3] = [__v_25, __v_9, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = G::from_u64(1); + let __v_28: G = (__v_2 + __v_27); + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1, __v_28, __v_26, __v_4, __v_5, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = result.output.try_into().unwrap(); __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_509] = [__v_29]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_509] = [__v_12]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_510: usize = 2; +const IN_510: usize = 2; +const OUT_510: usize = 1; +fn aiur_fn_510( + inp: [G; IN_510], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_510], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_510] = [__v_5]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = result.output.try_into().unwrap(); __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_511: usize = 2; +const IN_511: usize = 2; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: [G; IN_511], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_511], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_511] = [__v_5]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_9: G = (__v_6 - __v_1); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_511] = [__v_10]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_511] = [__v_10]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_511] = [__v_9]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_512: usize = 11; +const IN_512: usize = 11; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_512], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_11, __v_2, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = result.output.try_into().unwrap(); __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_13, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = result.output.try_into().unwrap(); __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(2); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_0, __v_4, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_17, __v_8, __v_3, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = result.output.try_into().unwrap(); __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_18, __v_3, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(5); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_20, __v_24, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_27, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_512] = [__v_28]; + record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_513: usize = 5; +const IN_513: usize = 5; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: [G; IN_513], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_513], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = result.output.try_into().unwrap(); __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_513] = [__v_6]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_4, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_513] = [__v_5]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_514: usize = 3; +const IN_514: usize = 3; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: [G; IN_514], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_514], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_514] = [__v_0]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_10, __v_5, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_514] = [__v_11]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_515: usize = 6; +const IN_515: usize = 6; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: [G; IN_515], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_515], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_515] = [__v_0]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = result.output.try_into().unwrap(); __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_1 - __v_13); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_5 + __v_15); + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = result.output.try_into().unwrap(); __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_515] = [__v_17]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_516: usize = 4; +const IN_516: usize = 4; +const OUT_516: usize = 1; +fn aiur_fn_516( + inp: [G; IN_516], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_516], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_516] = [__v_9]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_516] = [__v_6]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = (__v_8 - __v_0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_516] = [__v_11]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_517: usize = 4; +const IN_517: usize = 4; +const OUT_517: usize = 1; +fn aiur_fn_517( + inp: [G; IN_517], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_517], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_517] = [__v_4]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_4, __v_5, __v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_517] = [__v_7]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_518: usize = 2; +const IN_518: usize = 2; +const OUT_518: usize = 1; +fn aiur_fn_518( + inp: [G; IN_518], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_518], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 6u64 => { + let __ret: [G; OUT_518] = [__v_8]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_518] = [__v_14]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +const OUT_519: usize = 1; +fn aiur_fn_519( + inp: [G; IN_519], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_519], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_519] = [__v_0]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = result.output.try_into().unwrap(); __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_1 - __v_13); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_5 + __v_15); + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_519] = [__v_17]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_520: usize = 4; +const IN_520: usize = 4; +const OUT_520: usize = 1; +fn aiur_fn_520( + inp: [G; IN_520], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_520], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_520] = [__v_9]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_520] = [__v_8]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = (__v_8 - __v_0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_520] = [__v_11]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_521: usize = 2; +const IN_521: usize = 2; +const OUT_521: usize = 1; +fn aiur_fn_521( + inp: [G; IN_521], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_521], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_521] = [__v_4]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 - __v_7); + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = result.output.try_into().unwrap(); __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_521] = [__v_10]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_522: usize = 3; +const IN_522: usize = 3; +const OUT_522: usize = 1; +fn aiur_fn_522( + inp: [G; IN_522], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_522], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_522] = [__v_6]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(4); + let __v_6: G = (__v_0 + __v_2); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_522] = [__v_12]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_523: usize = 4; +const IN_523: usize = 4; +const OUT_523: usize = 1; +fn aiur_fn_523( + inp: [G; IN_523], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_523], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_523] = [__v_0]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __v_8: G = (__v_7 - __v_3); + let __v_9: G = (__v_8 + __v_2); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(3); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_3 + __v_15); + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = result.output.try_into().unwrap(); __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_523] = [__v_17]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_524: usize = 3; +const IN_524: usize = 3; +const OUT_524: usize = 1; +fn aiur_fn_524( + inp: [G; IN_524], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_524], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_524] = [__v_0]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_2); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(3); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_2 + __v_13); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_12, __v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_524] = [__v_15]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_525: usize = 2; +const IN_525: usize = 2; +const OUT_525: usize = 1; +fn aiur_fn_525( + inp: [G; IN_525], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_525], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_525] = [__v_0]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(5); + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_525] = [__v_8]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_526: usize = 14; +const IN_526: usize = 14; +const OUT_526: usize = 1; +fn aiur_fn_526( + inp: [G; IN_526], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_526], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = (__v_9 + __v_10); + let __v_16: G = (__v_8 + __v_15); + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = result.output.try_into().unwrap(); __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_14, __v_17, __v_16, __v_3, __v_4, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_0, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(1); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_6, __v_25, __v_28, __v_31, __v_34, __v_12, __v_13, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = (__v_40 + __v_41); + let __v_43: G = (__v_16 + __v_42); + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_45, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = G::from_u64(0); + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_46, __v_41, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = result.output.try_into().unwrap(); __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_43 - __v_49); + let __v_51: G = (__v_11 + __v_22); + let __v_52: G = (__v_50 - __v_51); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 4] = [__v_53, __v_52, __v_54, __v_54]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = G::from_u64(2); + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_1, __v_5, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_59, __v_17, __v_8, __v_43, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = result.output.try_into().unwrap(); __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(0); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_60, __v_40, __v_42, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = G::from_u64(3); + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_56, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(1); + let __v_67: G = G::from_u64(1); + let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(0); + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_37, __v_38, __v_36, __v_7, __v_11, __v_40, __v_16, __v_68, __v_12, __v_13, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = result.output.try_into().unwrap(); __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_65, __v_70]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __ret: [G; OUT_526] = [__v_72]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_527: usize = 6; +const IN_527: usize = 6; +const OUT_527: usize = 1; +fn aiur_fn_527( + inp: [G; IN_527], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_527], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_3 - __v_6); + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_527] = [__v_9]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_527] = [__v_6]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_528: usize = 4; +const IN_528: usize = 4; +const OUT_528: usize = 1; +fn aiur_fn_528( + inp: [G; IN_528], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_528], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_528] = [__v_0]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __v_11: G = (__v_10 - __v_3); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_8, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_1 - __v_16); + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_15, __v_17, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = result.output.try_into().unwrap(); __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_528] = [__v_20]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_529: usize = 9; +const IN_529: usize = 9; +const OUT_529: usize = 4; +fn aiur_fn_529( + inp: [G; IN_529], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_529], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_1, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = result.output.try_into().unwrap(); __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_10, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 3] = [__v_17, __v_10, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_19, __v_8, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_14, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_8 + __v_23); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __ret: [G; OUT_529] = [__v_25, __v_26, __v_27, __v_28]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_8 + __v_19); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __ret: [G; OUT_529] = [__v_21, __v_22, __v_23, __v_24]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_529] = [__v_13, __v_14, __v_15, __v_0]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_530: usize = 2; +const IN_530: usize = 2; +const OUT_530: usize = 1; +fn aiur_fn_530( + inp: [G; IN_530], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_530], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + match __v_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_48, __v_0, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_530] = [__v_52]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_1, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_530] = [__v_49]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_14, __v_0, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_530] = [__v_18]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_531: usize = 3; +const IN_531: usize = 3; +const OUT_531: usize = 1; +fn aiur_fn_531( + inp: [G; IN_531], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_531], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_531] = [__v_8]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_2 + __v_19); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_531] = [__v_22]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 + __v_18); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_531] = [__v_20]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_2 + __v_17); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_531] = [__v_19]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_532: usize = 3; +const IN_532: usize = 3; +const OUT_532: usize = 1; +fn aiur_fn_532( + inp: [G; IN_532], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_532], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 32] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + match __v_48.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_49]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_50: G = __loaded[0]; + let __v_51: G = __loaded[1]; + let __v_52: G = __loaded[2]; + let __v_53: G = __loaded[3]; + let __v_54: G = __loaded[4]; + let __v_55: G = __loaded[5]; + let __v_56: G = __loaded[6]; + let __v_57: G = __loaded[7]; + let __v_58: G = __loaded[8]; + let __v_59: G = __loaded[9]; + let __v_60: G = __loaded[10]; + match __v_50.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_61: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64())); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_15]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_533: usize = 5; +const IN_533: usize = 5; +const OUT_533: usize = 2; +fn aiur_fn_533( + inp: [G; IN_533], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_533], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_6, __v_8, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_13, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_533] = [__v_17, __v_18]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_533] = [__v_16, __v_17]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_534: usize = 3; +const IN_534: usize = 3; +const OUT_534: usize = 2; +fn aiur_fn_534( + inp: [G; IN_534], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_534], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_534] = [__v_6, __v_7]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = (__v_4 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_534] = [__v_7, __v_2]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_534] = [__v_9, __v_10]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_535: usize = 1; +const IN_535: usize = 1; +const OUT_535: usize = 2; +fn aiur_fn_535( + inp: [G; IN_535], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_535], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = result.output.try_into().unwrap(); __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_535] = [__v_6, __v_5]; + record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_536: usize = 2; +const IN_536: usize = 2; +const OUT_536: usize = 2; +fn aiur_fn_536( + inp: [G; IN_536], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_536], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = result.output.try_into().unwrap(); __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_536] = [__v_8, __v_9]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_536] = [__v_1, __v_0]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_537: usize = 3; +const IN_537: usize = 3; +const OUT_537: usize = 1; +fn aiur_fn_537( + inp: [G; IN_537], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_537], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_537] = [__v_8]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = result.output.try_into().unwrap(); __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_537] = [__v_9]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_538: usize = 4; +const IN_538: usize = 4; +const OUT_538: usize = 1; +fn aiur_fn_538( + inp: [G; IN_538], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_538], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_538] = [__v_0]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = (__v_2 - __v_3); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(3); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_3 + __v_12); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_538] = [__v_14]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_539: usize = 4; +const IN_539: usize = 4; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_539], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_539] = [__v_0]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_2 - __v_6); + let __v_8: G = (__v_7 - __v_3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(3); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_3 + __v_14); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_539] = [__v_16]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_540: usize = 2; +const IN_540: usize = 2; +const OUT_540: usize = 2; +fn aiur_fn_540( + inp: [G; IN_540], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_540], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = result.output.try_into().unwrap(); __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_540] = [__v_7, __v_6]; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_541: usize = 3; +const IN_541: usize = 3; +const OUT_541: usize = 2; +fn aiur_fn_541( + inp: [G; IN_541], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_541], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_541] = [__v_2, __v_0]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_8, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = result.output.try_into().unwrap(); __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_541] = [__v_11, __v_12]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_542: usize = 3; +const IN_542: usize = 3; +const OUT_542: usize = 1; +fn aiur_fn_542( + inp: [G; IN_542], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_542], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_542] = [__v_0]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = (__v_1 - __v_2); + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_2 + __v_11); + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = result.output.try_into().unwrap(); __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_542] = [__v_13]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_543: usize = 13; +const IN_543: usize = 13; +const OUT_543: usize = 1; +fn aiur_fn_543( + inp: [G; IN_543], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_543], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_543] = [__v_18]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_1, __v_14, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = result.output.try_into().unwrap(); __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_12 + __v_29); + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = result.output.try_into().unwrap(); __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 3] = [__v_32, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_543] = [__v_33]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_544: usize = 9; +const IN_544: usize = 9; +const OUT_544: usize = 1; +fn aiur_fn_544( + inp: [G; IN_544], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_544], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_544] = [__v_10]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_545: usize = 10; +const IN_545: usize = 10; +const OUT_545: usize = 1; +fn aiur_fn_545( + inp: [G; IN_545], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_545], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_545] = [__v_18]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_11, __v_19, __v_20, __v_21, __v_14, __v_3, __v_4, __v_5, __v_7, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = result.output.try_into().unwrap(); __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_28, __v_9, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(1); + let __v_33: G = (__v_9 + __v_32); + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_545] = [__v_35]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_545] = [__v_28]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_546: usize = 11; +const IN_546: usize = 11; +const OUT_546: usize = 1; +fn aiur_fn_546( + inp: [G; IN_546], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_546], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(1); + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_546] = [__v_19]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + match __v_18.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_23, __v_12, __v_13, __v_14, __v_15, __v_1, __v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = result.output.try_into().unwrap(); __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = (__v_10 + __v_30); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_29, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __ret: [G; OUT_546] = [__v_33]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_546] = [__v_29]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_547: usize = 10; +const IN_547: usize = 10; +const OUT_547: usize = 1; +fn aiur_fn_547( + inp: [G; IN_547], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_547], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = (__v_6 + __v_4); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_11, __v_12, __v_13, __v_2, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = result.output.try_into().unwrap(); __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + break '__mc_0 [__v_15, __v_16, __v_17]; + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + break '__mc_0 [__v_15, __v_16, __v_16]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, +} + }; + let __v_15: G = __mc_out___mc_0[0]; + let __v_16: G = __mc_out___mc_0[1]; + let __v_17: G = __mc_out___mc_0[2]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_18, __v_14, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = result.output.try_into().unwrap(); __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_19, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_19, __v_3, __v_5, __v_15, __v_16, __v_17, __v_14, __v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = result.output.try_into().unwrap(); __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_19, __v_20, __v_32, __v_3, __v_21, __v_5, __v_14, __v_3, __v_8, __v_9, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_31, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = (__v_21 + __v_36); + let __v_40: G = G::from_u64(0); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_37, __v_39, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = G::from_u64(2); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_49, __v_0, __v_48, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = (__v_36 + __v_4); + let __v_53: G = (__v_21 + __v_52); + let __v_54: G = (__v_3 + __v_53); + let __v_55: G = G::from_u64(1); + let __v_56: G = (__v_54 - __v_55); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_51, __v_3, __v_56, __v_4, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = result.output.try_into().unwrap(); __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_57, __v_4, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_54 + __v_60); + let __v_62: G = G::from_u64(1); + let __v_63: G = (__v_61 - __v_62); + let __v_64: G = (__v_3 + __v_44); + let __v_65: G = (__v_63 - __v_64); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(0); + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_68, __v_4, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = result.output.try_into().unwrap(); __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __v_71: G = G::from_u64(3); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 4] = [__v_72, __v_73, __v_74, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 4] = [__v_71, __v_70, __v_75, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = G::from_u64(5); + let __v_79: G = G::from_u64(0); + let __v_80: G = { let __values: [G; 4] = [__v_78, __v_59, __v_77, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_80, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_81, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_82, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_83, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __ret: [G; OUT_547] = [__v_84]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_548: usize = 21; +const IN_548: usize = 21; +const OUT_548: usize = 1; +fn aiur_fn_548( + inp: [G; IN_548], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_548], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = (__v_8 + __v_9); + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = result.output.try_into().unwrap(); __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = result.output.try_into().unwrap(); __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_24, __v_25, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = result.output.try_into().unwrap(); __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(1); + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(0); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_14, __v_29, __v_32, __v_35, __v_38, __v_19, __v_20, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = __r_arr[1]; + let __v_42: G = __r_arr[2]; + let __v_43: G = __r_arr[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = (__v_7 + __v_44); + let __v_47: G = (__v_6 + __v_46); + let __v_48: G = (__v_5 + __v_47); + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_48 - __v_49); + let __v_51: G = (__v_6 + __v_4); + let __v_52: G = (__v_5 + __v_51); + let __v_53: G = (__v_50 - __v_52); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = G::from_u64(0); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_56, __v_44, __v_44, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = G::from_u64(1); + let __v_60: G = G::from_u64(1); + let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_58, __v_41, __v_42, __v_40, __v_13, __v_15, __v_5, __v_6, __v_7, __v_44, __v_23, __v_61, __v_19, __v_20, __v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = result.output.try_into().unwrap(); __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = (__v_6 + __v_7); + let __v_65: G = G::from_u64(0); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_40, __v_64, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_63, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_67, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_68, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_69, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __ret: [G; OUT_548] = [__v_70]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_549: usize = 2; +const IN_549: usize = 2; +const OUT_549: usize = 1; +fn aiur_fn_549( + inp: [G; IN_549], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_549], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_549] = [__v_5]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(4); + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 + __v_7); + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = result.output.try_into().unwrap(); __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_549] = [__v_10]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_550: usize = 2; +const IN_550: usize = 2; +const OUT_550: usize = 1; +fn aiur_fn_550( + inp: [G; IN_550], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_550], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_550] = [__v_0]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(4); + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_550] = [__v_8]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_551: usize = 15; +const IN_551: usize = 15; +const OUT_551: usize = 1; +fn aiur_fn_551( + inp: [G; IN_551], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_551], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_551] = [__v_0]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = (__v_8 + __v_9); + let __v_22: G = (__v_7 + __v_21); + let __v_23: G = (__v_6 + __v_22); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = (__v_9 - __v_16); + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = (__v_7 + __v_8); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_27, __v_28, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_29, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_33, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_32, __v_34, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = (__v_23 + __v_36); + let __v_38: G = G::from_u64(2); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_19, __v_10, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(1); + let __v_42: G = (__v_37 - __v_41); + let __v_43: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_40, __v_6, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = G::from_u64(1); + let __v_46: G = (__v_37 - __v_45); + let __v_47: G = (__v_46 - __v_6); + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_44, __v_7, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_37 - __v_50); + let __v_52: G = (__v_51 - __v_6); + let __v_53: G = (__v_52 - __v_7); + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_49, __v_8, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_57, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_9 - __v_60); + let __v_62: G = (__v_61 - __v_16); + let __v_63: G = (__v_62 + __v_36); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_66, __v_36, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_59, __v_68, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_71, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __v_73: G = G::from_u64(3); + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(1); + let __v_77: G = (__v_14 + __v_76); + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = result.output.try_into().unwrap(); __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __ret: [G; OUT_551] = [__v_78]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_552: usize = 7; +const IN_552: usize = 7; +const OUT_552: usize = 1; +fn aiur_fn_552( + inp: [G; IN_552], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_552], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = (__v_4 + __v_5); + let __v_8: G = (__v_3 + __v_7); + let __v_9: G = (__v_2 + __v_8); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 2u64 => { + let __ret: [G; OUT_552] = [__v_18]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_553: usize = 3; +const IN_553: usize = 3; +const OUT_553: usize = 1; +fn aiur_fn_553( + inp: [G; IN_553], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_553], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_553] = [__v_8]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_553] = [__v_5]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_554: usize = 6; +const IN_554: usize = 6; +const OUT_554: usize = 1; +fn aiur_fn_554( + inp: [G; IN_554], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_554], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_554] = [__v_9]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = (__v_20 - __v_0); + let __v_22: G = G::from_bool((__v_21 == G::ZERO)); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(1); + break '__mc_0 [__v_23]; + }, + _ => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + break '__mc_0 [__v_23]; + }, +} + }; + let __v_23: G = __mc_out___mc_0[0]; + let __v_24: G = (__v_22 * __v_23); + match __v_24.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_554] = [__v_5]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_25: G = G::from_u64(1); + let __v_26: G = (__v_5 + __v_25); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __ret: [G; OUT_554] = [__v_27]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(1); + let __v_21: G = (__v_5 + __v_20); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_554] = [__v_22]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_555: usize = 3; +const IN_555: usize = 3; +const OUT_555: usize = 1; +fn aiur_fn_555( + inp: [G; IN_555], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_555], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_555] = [__v_8]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = result.output.try_into().unwrap(); __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = result.output.try_into().unwrap(); __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_555] = [__v_9]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_556: usize = 2; +const IN_556: usize = 2; +const OUT_556: usize = 1; +fn aiur_fn_556( + inp: [G; IN_556], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_556], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __ret: [G; OUT_556] = [__v_11]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_557: usize = 3; +const IN_557: usize = 3; +const OUT_557: usize = 1; +fn aiur_fn_557( + inp: [G; IN_557], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_557], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_557] = [__v_8]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_2 + __v_8); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_557] = [__v_11]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_558: usize = 4; +const IN_558: usize = 4; +const OUT_558: usize = 0; +fn aiur_fn_558( + inp: [G; IN_558], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_558], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + match __v_9.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + _ => { + match __v_10.as_canonical_u64() { + _ => { + if (__v_5 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_6 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + if (__v_17 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = result.output.try_into().unwrap(); __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_559: usize = 13; +const IN_559: usize = 13; +const OUT_559: usize = 0; +fn aiur_fn_559( + inp: [G; IN_559], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_559], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + match __v_1.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + let __v_20: G = __loaded[6]; + let __v_21: G = __loaded[7]; + let __v_22: G = __loaded[8]; + let __v_23: G = __loaded[9]; + let __v_24: G = __loaded[10]; + match __v_14.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + if (__v_25 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() }); + } + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_560: usize = 2; +const IN_560: usize = 2; +const OUT_560: usize = 1; +fn aiur_fn_560( + inp: [G; IN_560], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_560], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_15 - __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = (__v_6 + __v_7); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + match __v_24.as_canonical_u64() { + 0u64 => { + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_25]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 - __v_26); + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + let __v_34: G = __loaded[3]; + let __v_35: G = __loaded[4]; + let __v_36: G = __loaded[5]; + let __v_37: G = __loaded[6]; + let __v_38: G = __loaded[7]; + let __v_39: G = __loaded[8]; + let __v_40: G = __loaded[9]; + let __v_41: G = __loaded[10]; + match __v_31.as_canonical_u64() { + 6u64 => { + let __v_42: G = G::from_bool((__v_37 == G::ZERO)); + let __ret: [G; OUT_560] = [__v_42]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_42]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_28: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_28]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_18]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_14]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_561: usize = 14; +const IN_561: usize = 14; +const OUT_561: usize = 0; +fn aiur_fn_561( + inp: [G; IN_561], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_561], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + match __v_1.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = result.output.try_into().unwrap(); __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_14, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = result.output.try_into().unwrap(); __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + if (__v_9 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_30: G = __loaded[0]; + let __v_31: G = __loaded[1]; + let __v_32: G = __loaded[2]; + let __v_33: G = __loaded[3]; + let __v_34: G = __loaded[4]; + let __v_35: G = __loaded[5]; + let __v_36: G = __loaded[6]; + let __v_37: G = __loaded[7]; + let __v_38: G = __loaded[8]; + let __v_39: G = __loaded[9]; + let __v_40: G = __loaded[10]; + match __v_18.as_canonical_u64() { + 5u64 => { + match __v_30.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = result.output.try_into().unwrap(); __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(1); + let __v_43: G = G::from_u64(1); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3, __v_41, __v_44, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(1); + if (__v_45 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + let __v_47: G = (__v_33 + __v_34); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_32, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_48, __v_49, __v_50, __v_35, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = result.output.try_into().unwrap(); __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_51.as_canonical_u64() { + 1u64 => { + let __v_52: G = G::from_u64(4); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + break '__mc_0 [__v_52, __v_53, __v_54]; + }, + 0u64 => { + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + break '__mc_0 [__v_52, __v_53, __v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64())); + }, +} + }; + let __v_52: G = __mc_out___mc_0[0]; + let __v_53: G = __mc_out___mc_0[1]; + let __v_54: G = __mc_out___mc_0[2]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_15, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_55, __v_51, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = result.output.try_into().unwrap(); __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_56, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_56, __v_21, __v_19, __v_52, __v_53, __v_54, __v_51, __v_21, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = result.output.try_into().unwrap(); __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(0); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_56, __v_57, __v_59, __v_21, __v_58, __v_19, __v_51, __v_21, __v_12, __v_13, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(0); + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_57, __v_14, __v_12, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_51, __v_19, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_68, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = __r_arr[1]; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_57, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = result.output.try_into().unwrap(); __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_57, __v_14, __v_72]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_56, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = __r_arr[2]; + let __v_78: G = __r_arr[3]; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_51, __v_60, __v_62, __v_69, __v_71, __v_57, __v_59, __v_76, __v_77, __v_78, __v_12, __v_13, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = result.output.try_into().unwrap(); __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_79, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = result.output.try_into().unwrap(); __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_561] = []; + record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_562: usize = 3; +const IN_562: usize = 3; +const OUT_562: usize = 1; +fn aiur_fn_562( + inp: [G; IN_562], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_562], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = result.output.try_into().unwrap(); __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = result.output.try_into().unwrap(); __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_562] = [__v_6]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_563: usize = 3; +const IN_563: usize = 3; +const OUT_563: usize = 1; +fn aiur_fn_563( + inp: [G; IN_563], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_563], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_8]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_26]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_27]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_564: usize = 1; +const IN_564: usize = 1; +const OUT_564: usize = 1; +fn aiur_fn_564( + inp: [G; IN_564], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_564], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_564] = [__v_8]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = result.output.try_into().unwrap(); __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 6] = [__v_6, __v_2, __v_7, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_564] = [__v_9]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_565: usize = 1; +const IN_565: usize = 1; +const OUT_565: usize = 1; +fn aiur_fn_565( + inp: [G; IN_565], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_565], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_565] = [__v_9]; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_565] = [__v_9]; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_566: usize = 2; +const IN_566: usize = 2; +const OUT_566: usize = 4; +fn aiur_fn_566( + inp: [G; IN_566], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_566], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_566] = [__v_8, __v_9, __v_12, __v_15]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_566] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 - __v_8); + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __ret: [G; OUT_566] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_567: usize = 6; +const IN_567: usize = 6; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: [G; IN_567], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_567], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_567] = [__v_7]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_567] = [__v_6]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_568: usize = 2; +const IN_568: usize = 2; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: [G; IN_568], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_568], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_10]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_22]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_23]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_569: usize = 3; +const IN_569: usize = 3; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_569], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + match __v_36.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_569] = [__v_0]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_37: G = G::from_u64(0); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_1, __v_2, __v_2, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + match __v_38.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_569] = [__v_39]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_569] = [__v_0]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_570: usize = 4; +const IN_570: usize = 4; +const OUT_570: usize = 2; +fn aiur_fn_570( + inp: [G; IN_570], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_570], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_570] = [__v_7, __v_8]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_3 + __v_19); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_21, __v_22]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 5u64 => { + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(1); + let __v_33: G = (__v_3 + __v_32); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_34, __v_35]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_32: G = G::from_u64(1); + let __ret: [G; OUT_570] = [__v_32, __v_19]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(1); + let __v_33: G = (__v_3 + __v_32); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_34, __v_35]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_20, __v_21]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_571: usize = 4; +const IN_571: usize = 4; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: [G; IN_571], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_571], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_571] = [__v_3]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = (__v_5 - __v_1); + let __v_8: G = G::from_bool((__v_7 == G::ZERO)); + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_571] = [__v_3]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + let __v_20: G = __loaded[10]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = (__v_3 + __v_21); + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_571] = [__v_23]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_571] = [__v_21]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_572: usize = 2; +const IN_572: usize = 2; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: [G; IN_572], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_572], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + match __v_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_48]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_13, __v_1, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_572] = [__v_49]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_48]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_14]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_573: usize = 3; +const IN_573: usize = 3; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_573], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_573] = [__v_6]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_17 * __v_15); + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_2 + __v_19); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_573] = [__v_21]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_573] = [__v_19]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_2 + __v_17); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_573] = [__v_19]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_574: usize = 3; +const IN_574: usize = 3; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: [G; IN_574], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_574], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_9, __v_7, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_574] = [__v_15]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 5] = [__v_15, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_574] = [__v_17]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_575: usize = 4; +const IN_575: usize = 4; +const OUT_575: usize = 1; +fn aiur_fn_575( + inp: [G; IN_575], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_575], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_575] = [__v_9]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_19, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = result.output.try_into().unwrap(); __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_575] = [__v_22]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_575] = [__v_19]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_576: usize = 3; +const IN_576: usize = 3; +const OUT_576: usize = 1; +fn aiur_fn_576( + inp: [G; IN_576], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_576], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = result.output.try_into().unwrap(); __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = result.output.try_into().unwrap(); __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_576] = [__v_9]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_576] = [__v_9]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_577: usize = 3; +const IN_577: usize = 3; +const OUT_577: usize = 1; +fn aiur_fn_577( + inp: [G; IN_577], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_577], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 5] = [__v_12, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_14]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = { let __a_val = __v_24.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 5] = [__v_26, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_28]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_26, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 5] = [__v_28, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_30]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 5] = [__v_29, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 5] = [__v_28, __v_8, __v_26, __v_9, __v_31]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_32]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(1); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_26]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 5] = [__v_11, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_13]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_578: usize = 3; +const IN_578: usize = 3; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: [G; IN_578], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_578], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = result.output.try_into().unwrap(); __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_578] = [__v_4]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_579: usize = 4; +const IN_579: usize = 4; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: [G; IN_579], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_579], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_579] = [__v_0]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_1 - __v_11); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_3 + __v_13); + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_12, __v_2, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = result.output.try_into().unwrap(); __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_579] = [__v_15]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_580: usize = 2; +const IN_580: usize = 2; +const OUT_580: usize = 0; +fn aiur_fn_580( + inp: [G; IN_580], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_580], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_2, __v_3, __v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_581: usize = 2; +const IN_581: usize = 2; +const OUT_581: usize = 2; +fn aiur_fn_581( + inp: [G; IN_581], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_581], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_581] = [__v_5, __v_8]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_6, __v_7]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_10, __v_18]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_18, __v_19]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_582: usize = 3; +const IN_582: usize = 3; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_582], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 5] = [__v_6, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_582] = [__v_8]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_582] = [__v_7]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = result.output.try_into().unwrap(); __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_582] = [__v_9]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_583: usize = 5; +const IN_583: usize = 5; +const OUT_583: usize = 0; +fn aiur_fn_583( + inp: [G; IN_583], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_583], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + let __v_16: G = __loaded[6]; + let __v_17: G = __loaded[7]; + let __v_18: G = __loaded[8]; + let __v_19: G = __loaded[9]; + let __v_20: G = __loaded[10]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + if (__v_21 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_584: usize = 6; +const IN_584: usize = 6; +const OUT_584: usize = 1; +fn aiur_fn_584( + inp: [G; IN_584], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_584], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + match __v_12.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_15, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = result.output.try_into().unwrap(); __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = (__v_26 - __v_27); + match __v_28.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = result.output.try_into().unwrap(); __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + match __v_29.as_canonical_u64() { + 1u64 => { + let __v_30: G = G::from_u64(1); + let __ret: [G; OUT_584] = [__v_30]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_30]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_29]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_26]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_23]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_585: usize = 6; +const IN_585: usize = 6; +const OUT_585: usize = 1; +fn aiur_fn_585( + inp: [G; IN_585], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_585], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + let __v_28: G = __loaded[3]; + let __v_29: G = __loaded[4]; + let __v_30: G = __loaded[5]; + let __v_31: G = __loaded[6]; + let __v_32: G = __loaded[7]; + let __v_33: G = __loaded[8]; + let __v_34: G = __loaded[9]; + let __v_35: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 6u64 => { + match __v_25.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_27, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = result.output.try_into().unwrap(); __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_36, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_37, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + match __v_38.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = result.output.try_into().unwrap(); __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_585] = [__v_39]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_39: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_39]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_36]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_36]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_586: usize = 20; +const IN_586: usize = 20; +const OUT_586: usize = 1; +fn aiur_fn_586( + inp: [G; IN_586], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_586], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 5] = [__v_23, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_586] = [__v_25]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_17, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_27, __v_21, __v_26, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = result.output.try_into().unwrap(); __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(1); + let __v_38: G = (__v_19 + __v_37); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_22, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = result.output.try_into().unwrap(); __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = { let __values: [G; 5] = [__v_36, __v_21, __v_30, __v_35, __v_39]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_586] = [__v_40]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_587: usize = 11; +const IN_587: usize = 11; +const OUT_587: usize = 1; +fn aiur_fn_587( + inp: [G; IN_587], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_587], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_587] = [__v_16]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_5 + __v_10); + let __v_17: G = (__v_6 + __v_16); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_5 - __v_12); + let __v_20: G = (__v_19 + __v_10); + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_18, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_26, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_25, __v_27, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = (__v_17 + __v_29); + let __v_31: G = G::from_u64(1); + let __v_32: G = (__v_30 - __v_31); + let __v_33: G = (__v_4 + __v_14); + let __v_34: G = (__v_32 - __v_33); + let __v_35: G = G::from_u64(1); + let __v_36: G = (__v_30 - __v_35); + let __v_37: G = (__v_6 + __v_12); + let __v_38: G = (__v_36 - __v_37); + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_40, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_34, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_38, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_48, __v_29, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(3); + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_51, __v_45, __v_50, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_53, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_10 + __v_56); + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = result.output.try_into().unwrap(); __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_587] = [__v_59]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_588: usize = 7; +const IN_588: usize = 7; +const OUT_588: usize = 0; +fn aiur_fn_588( + inp: [G; IN_588], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_588], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_4, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + match __v_40.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_588] = []; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_41: G = G::from_u64(0); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_588] = []; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_589: usize = 9; +const IN_589: usize = 9; +const OUT_589: usize = 0; +fn aiur_fn_589( + inp: [G; IN_589], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_589], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + let __v_22: G = __loaded[10]; + match __v_12.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_22, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = (__v_8 - __v_0); + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_26 - __v_25); + let __v_28: G = (__v_23 * __v_27); + match __v_28.as_canonical_u64() { + 1u64 => { + if (__v_15 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_14, __v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = result.output.try_into().unwrap(); __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __v_29: G = (__v_2 + __v_3); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __v_32: G = __r_arr[2]; + let __v_33: G = (__v_15 + __v_16); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_30, __v_31, __v_32, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(1); + if (__v_37 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + let __v_39: G = G::from_u64(1); + let __v_40: G = (__v_8 + __v_39); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_8 + __v_29); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_8 + __v_23); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_590: usize = 5; +const IN_590: usize = 5; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_590], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = result.output.try_into().unwrap(); __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_591: usize = 6; +const IN_591: usize = 6; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: [G; IN_591], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_591], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_591] = []; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(1); + if (__v_14 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 - __v_18); + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = result.output.try_into().unwrap(); __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_592: usize = 2; +const IN_592: usize = 2; +const OUT_592: usize = 1; +fn aiur_fn_592( + inp: [G; IN_592], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_592], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_592] = [__v_3]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_592] = [__v_4]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(2); + let __ret: [G; OUT_592] = [__v_4]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_593: usize = 2; +const IN_593: usize = 2; +const OUT_593: usize = 1; +fn aiur_fn_593( + inp: [G; IN_593], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_593], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_593] = [__v_1]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_593] = [__v_0]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_594: usize = 0; +const IN_594: usize = 0; +const OUT_594: usize = 2; +fn aiur_fn_594( + inp: [G; IN_594], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_594], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_594] = [__v_0, __v_1]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_595: usize = 0; +const IN_595: usize = 0; +const OUT_595: usize = 2; +fn aiur_fn_595( + inp: [G; IN_595], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_595], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_595] = [__v_0, __v_1]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_596: usize = 0; +const IN_596: usize = 0; +const OUT_596: usize = 2; +fn aiur_fn_596( + inp: [G; IN_596], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_596], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_596] = [__v_0, __v_1]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_597: usize = 0; +const IN_597: usize = 0; +const OUT_597: usize = 2; +fn aiur_fn_597( + inp: [G; IN_597], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_597], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_597] = [__v_0, __v_1]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_598: usize = 0; +const IN_598: usize = 0; +const OUT_598: usize = 2; +fn aiur_fn_598( + inp: [G; IN_598], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_598], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(2); + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_598] = [__v_0, __v_1]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_599: usize = 4; +const IN_599: usize = 4; +const OUT_599: usize = 2; +fn aiur_fn_599( + inp: [G; IN_599], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_599], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_4: G = (__v_1 * __v_3); + let __ret: [G; OUT_599] = [__v_2, __v_4]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_599] = [__v_0, __v_1]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_600: usize = 1; +const IN_600: usize = 1; +const OUT_600: usize = 2; +fn aiur_fn_600( + inp: [G; IN_600], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_600], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_600] = [__v_0, __v_1]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_601: usize = 3; +const IN_601: usize = 3; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_601], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_601] = [__v_6]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = (__v_4 - __v_0); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_7 + __v_2); + let __ret: [G; OUT_601] = [__v_8]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_601] = [__v_9]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_602: usize = 3; +const IN_602: usize = 3; +const OUT_602: usize = 2; +fn aiur_fn_602( + inp: [G; IN_602], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_602], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_8, __v_9]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_603: usize = 6; +const IN_603: usize = 6; +const OUT_603: usize = 1; +fn aiur_fn_603( + inp: [G; IN_603], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_603], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_9]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_9]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_20]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_20]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_3.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_604: usize = 2; +const IN_604: usize = 2; +const OUT_604: usize = 1; +fn aiur_fn_604( + inp: [G; IN_604], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_604], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_604] = [__v_8]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_604] = [__v_8]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_604] = [__v_11]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_5, __v_6, __v_7, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_604] = [__v_16]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_605: usize = 2; +const IN_605: usize = 2; +const OUT_605: usize = 2; +fn aiur_fn_605( + inp: [G; IN_605], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_605], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __ret: [G; OUT_605] = [__v_3, __v_4]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_606: usize = 2; +const IN_606: usize = 2; +const OUT_606: usize = 1; +fn aiur_fn_606( + inp: [G; IN_606], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_606], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_606] = [__v_3]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = result.output.try_into().unwrap(); __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_606] = [__v_11]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_607: usize = 8; +const IN_607: usize = 8; +const OUT_607: usize = 1; +fn aiur_fn_607( + inp: [G; IN_607], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_607], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_11]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_14]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_11]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_12]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = result.output.try_into().unwrap(); __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_12]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_608: usize = 3; +const IN_608: usize = 3; +const OUT_608: usize = 2; +fn aiur_fn_608( + inp: [G; IN_608], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_608], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_0 - __v_1); + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = result.output.try_into().unwrap(); __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __ret: [G; OUT_608] = [__v_4, __v_5]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = result.output.try_into().unwrap(); __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_608] = [__v_12, __v_13]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_609: usize = 9; +const IN_609: usize = 9; +const OUT_609: usize = 2; +fn aiur_fn_609( + inp: [G; IN_609], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_609], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_10, __v_11]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_12, __v_13]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_16, __v_17]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_12, __v_13]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = result.output.try_into().unwrap(); __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = result.output.try_into().unwrap(); __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_17, __v_18]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = result.output.try_into().unwrap(); __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_10, __v_11]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = result.output.try_into().unwrap(); __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_18, __v_19]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_610: usize = 4; +const IN_610: usize = 4; +const OUT_610: usize = 1; +fn aiur_fn_610( + inp: [G; IN_610], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_610], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = result.output.try_into().unwrap(); __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(2); + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = result.output.try_into().unwrap(); __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_611: usize = 2; +const IN_611: usize = 2; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_611], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = result.output.try_into().unwrap(); __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_611] = [__v_7]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_611] = [__v_6]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_612: usize = 2; +const IN_612: usize = 2; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_612], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_612] = [__v_12]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = result.output.try_into().unwrap(); __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = result.output.try_into().unwrap(); __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_612] = [__v_24]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_613: usize = 16; +const IN_613: usize = 16; +const OUT_613: usize = 1; +fn aiur_fn_613( + inp: [G; IN_613], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_613], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_20, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_19, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_17, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_16, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_613] = [__v_30]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_614: usize = 2; +const IN_614: usize = 2; +const OUT_614: usize = 1; +fn aiur_fn_614( + inp: [G; IN_614], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_614], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = result.output.try_into().unwrap(); __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_615: usize = 6; +const IN_615: usize = 6; +const OUT_615: usize = 1; +fn aiur_fn_615( + inp: [G; IN_615], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_615], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + _ => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_615] = [__v_10]; + record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_616: usize = 2; +const IN_616: usize = 2; +const OUT_616: usize = 1; +fn aiur_fn_616( + inp: [G; IN_616], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_616], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = result.output.try_into().unwrap(); __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = result.output.try_into().unwrap(); __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_616] = [__v_14]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_617: usize = 7; +const IN_617: usize = 7; +const OUT_617: usize = 2; +fn aiur_fn_617( + inp: [G; IN_617], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_617], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + match __v_0.as_canonical_u64() { + _ => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_9, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_617] = [__v_17, __v_18]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_618: usize = 3; +const IN_618: usize = 3; +const OUT_618: usize = 2; +fn aiur_fn_618( + inp: [G; IN_618], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_618], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = result.output.try_into().unwrap(); __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = result.output.try_into().unwrap(); __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_12, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = result.output.try_into().unwrap(); __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_17, __v_18]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_619: usize = 11; +const IN_619: usize = 11; +const OUT_619: usize = 1; +fn aiur_fn_619( + inp: [G; IN_619], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_619], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_11: G = G::from_u64(3); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(4); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_11: G = G::from_u64(5); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_620: usize = 22; +const IN_620: usize = 22; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_620], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + match __v_24.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = result.output.try_into().unwrap(); __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_620] = [__v_25]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_620] = [__v_24]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_621: usize = 22; +const IN_621: usize = 22; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: [G; IN_621], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_621], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_11.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_28]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_11.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_24]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_27, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_36]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_11.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_30]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_11.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = result.output.try_into().unwrap(); __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_27, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_36]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_622: usize = 23; +const IN_622: usize = 23; +const OUT_622: usize = 2; +fn aiur_fn_622( + inp: [G; IN_622], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_622], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = result.output.try_into().unwrap(); __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_622] = [__v_26, __v_27]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_622] = [__v_26, __v_27]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_623: usize = 23; +const IN_623: usize = 23; +const OUT_623: usize = 2; +fn aiur_fn_623( + inp: [G; IN_623], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_623], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_32, __v_33]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_32, __v_33]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_11.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_28, __v_29, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_37, __v_38]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_11.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_28, __v_29]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_33, __v_34]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_38, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_55, __v_56]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_11.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_39, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_41, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_43, __v_44]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_11.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_18, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = result.output.try_into().unwrap(); __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_39, __v_40, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_57, __v_58]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_624: usize = 4; +const IN_624: usize = 4; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: [G; IN_624], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_624], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_624] = [__v_9]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = result.output.try_into().unwrap(); __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_3 + __v_19); + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = result.output.try_into().unwrap(); __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_23, __v_3, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_624] = [__v_24]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_624] = [__v_21]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_625: usize = 1; +const IN_625: usize = 1; +const OUT_625: usize = 0; +fn aiur_fn_625( + inp: [G; IN_625], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_625], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(1); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = G::from_u64(0); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_33, __v_36, __v_37, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_625] = []; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_626: usize = 12; +const IN_626: usize = 12; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_626], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + match __v_0.as_canonical_u64() { + 5u64 => { + let __ret: [G; OUT_626] = [__v_10]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 5u64 => { + let __ret: [G; OUT_626] = [__v_23]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 32] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_626] = [__v_56]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + let __ret: [G; OUT_626] = [__v_10]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_626] = [__v_44]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_627: usize = 5; +const IN_627: usize = 5; +const OUT_627: usize = 0; +fn aiur_fn_627( + inp: [G; IN_627], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_627], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = result.output.try_into().unwrap(); __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = result.output.try_into().unwrap(); __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_3 + __v_22); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = result.output.try_into().unwrap(); __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_19, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = result.output.try_into().unwrap(); __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_3 + __v_22); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_628: usize = 2; +const IN_628: usize = 2; +const OUT_628: usize = 1; +fn aiur_fn_628( + inp: [G; IN_628], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_628], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + match __v_35.as_canonical_u64() { + 1u64 => { + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_628] = [__v_38]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(1); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_36, __v_1, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_628] = [__v_40]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_629: usize = 3; +const IN_629: usize = 3; +const OUT_629: usize = 0; +fn aiur_fn_629( + inp: [G; IN_629], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_629], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + match __v_36.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + match __v_37.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = result.output.try_into().unwrap(); __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_630: usize = 2; +const IN_630: usize = 2; +const OUT_630: usize = 0; +fn aiur_fn_630( + inp: [G; IN_630], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_630], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = result.output.try_into().unwrap(); __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_630] = []; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_630] = []; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = result.output.try_into().unwrap(); __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = result.output.try_into().unwrap(); __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_6, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_5 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + if (__v_7 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + let __ret: [G; OUT_630] = []; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_631: usize = 2; +const IN_631: usize = 2; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: [G; IN_631], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_631], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_631] = [__v_7]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = result.output.try_into().unwrap(); __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_631] = [__v_20]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_631] = [__v_17]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_632: usize = 1; +const IN_632: usize = 1; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_632], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_632] = [__v_4]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = result.output.try_into().unwrap(); __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_632] = [__v_5]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_632] = [__v_5]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_633: usize = 1; +const IN_633: usize = 1; +const OUT_633: usize = 1; +fn aiur_fn_633( + inp: [G; IN_633], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_633], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_633] = [__v_6]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_633] = [__v_5]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_634: usize = 2; +const IN_634: usize = 2; +const OUT_634: usize = 1; +fn aiur_fn_634( + inp: [G; IN_634], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_634], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(32); + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = result.output.try_into().unwrap(); __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_634] = [__v_8]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_635: usize = 3; +const IN_635: usize = 3; +const OUT_635: usize = 1; +fn aiur_fn_635( + inp: [G; IN_635], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_635], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_635] = [__v_0]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = result.output.try_into().unwrap(); __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = result.output.try_into().unwrap(); __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_635] = [__v_0]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_2 - __v_6); + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = result.output.try_into().unwrap(); __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_635] = [__v_8]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: [G; IN_636], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_636], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_636] = [__v_8]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = result.output.try_into().unwrap(); __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = result.output.try_into().unwrap(); __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_636] = [__v_8]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_637: usize = 3; +const IN_637: usize = 3; +const OUT_637: usize = 1; +fn aiur_fn_637( + inp: [G; IN_637], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_637], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_637] = [__v_6]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_637] = [__v_8]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = result.output.try_into().unwrap(); __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = result.output.try_into().unwrap(); __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_637] = [__v_5]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_638: usize = 3; +const IN_638: usize = 3; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: [G; IN_638], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_638], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_638] = [__v_8]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = result.output.try_into().unwrap(); __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = result.output.try_into().unwrap(); __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_638] = [__v_7]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_639: usize = 4; +const IN_639: usize = 4; +const OUT_639: usize = 1; +fn aiur_fn_639( + inp: [G; IN_639], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_639], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_639] = [__v_11]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = result.output.try_into().unwrap(); __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_639] = [__v_34]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = result.output.try_into().unwrap(); __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_639] = [__v_35]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_640: usize = 3; +const IN_640: usize = 3; +const OUT_640: usize = 1; +fn aiur_fn_640( + inp: [G; IN_640], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_640], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_640] = [__v_8]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_640] = [__v_11]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_641: usize = 5; +const IN_641: usize = 5; +const OUT_641: usize = 1; +fn aiur_fn_641( + inp: [G; IN_641], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_641], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_641] = [__v_12]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = result.output.try_into().unwrap(); __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + match __v_32.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __ret: [G; OUT_641] = [__v_35]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_641] = [__v_41]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_642: usize = 2; +const IN_642: usize = 2; +const OUT_642: usize = 1; +fn aiur_fn_642( + inp: [G; IN_642], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_642], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_9]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = result.output.try_into().unwrap(); __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_642] = [__v_9]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_643: usize = 11; +const IN_643: usize = 11; +const OUT_643: usize = 1; +fn aiur_fn_643( + inp: [G; IN_643], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_643], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_643] = [__v_3]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_643] = [__v_4]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_643] = [__v_8]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_643] = [__v_7]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_643] = [__v_9]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_644: usize = 2; +const IN_644: usize = 2; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: [G; IN_644], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_644], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = result.output.try_into().unwrap(); __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 - __v_19); + let __ret: [G; OUT_644] = [__v_20]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_7 * __v_8); + let __v_10: G = (__v_6 * __v_9); + let __ret: [G; OUT_644] = [__v_10]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_645: usize = 3; +const IN_645: usize = 3; +const OUT_645: usize = 0; +fn aiur_fn_645( + inp: [G; IN_645], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_645], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_645] = []; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_645] = []; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_646: usize = 4; +const IN_646: usize = 4; +const OUT_646: usize = 0; +fn aiur_fn_646( + inp: [G; IN_646], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_646], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_4: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_5: G = G::from_u64(1); + if (__v_4 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_647: usize = 2; +const IN_647: usize = 2; +const OUT_647: usize = 0; +fn aiur_fn_647( + inp: [G; IN_647], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_647], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_647] = []; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = result.output.try_into().unwrap(); __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_647] = []; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_648: usize = 4; +const IN_648: usize = 4; +const OUT_648: usize = 0; +fn aiur_fn_648( + inp: [G; IN_648], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_648], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = G::from_u64(1); + if (__v_8 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9, __v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + if (__v_21 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = result.output.try_into().unwrap(); __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_649: usize = 12; +const IN_649: usize = 12; +const OUT_649: usize = 0; +fn aiur_fn_649( + inp: [G; IN_649], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_649], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = result.output.try_into().unwrap(); __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_650: usize = 3; +const IN_650: usize = 3; +const OUT_650: usize = 0; +fn aiur_fn_650( + inp: [G; IN_650], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_650], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_4.as_canonical_u64() { + _ => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_8, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = result.output.try_into().unwrap(); __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 0; +fn aiur_fn_651( + inp: [G; IN_651], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_651], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = result.output.try_into().unwrap(); __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_17: G = G::from_u64(1); + if (__v_7 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + let __v_18: G = G::from_u64(2); + if (__v_9 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(1); + if (__v_19 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + if (__v_25 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_652: usize = 14; +const IN_652: usize = 14; +const OUT_652: usize = 0; +fn aiur_fn_652( + inp: [G; IN_652], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_652], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = result.output.try_into().unwrap(); __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = result.output.try_into().unwrap(); __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(1); + if (__v_24 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); + } + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_28, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = result.output.try_into().unwrap(); __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = result.output.try_into().unwrap(); __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_19, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = result.output.try_into().unwrap(); __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_3, __v_19, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + if (__v_6 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = result.output.try_into().unwrap(); __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + match __v_20.as_canonical_u64() { + 5u64 => { + if (__v_5 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_22, __v_2, __v_23, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = result.output.try_into().unwrap(); __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = result.output.try_into().unwrap(); __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __v_31: G = (__v_23 + __v_24); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = G::from_u64(1); + let __v_36: G = G::from_u64(1); + let __v_37: G = { let __values: [G; 3] = [__v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_5, __v_32, __v_33, __v_34, __v_37, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = result.output.try_into().unwrap(); __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __v_38: G = G::from_u64(1); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 3] = [__v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5, __v_3, __v_40, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = result.output.try_into().unwrap(); __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 7u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = result.output.try_into().unwrap(); __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_653: usize = 6; +const IN_653: usize = 6; +const OUT_653: usize = 0; +fn aiur_fn_653( + inp: [G; IN_653], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_653], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = result.output.try_into().unwrap(); __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(2); + break '__mc_0 [__v_9, __v_10]; + }, + 1u64 => { + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = result.output.try_into().unwrap(); __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(3); + break '__mc_0 [__v_9, __v_10]; + }, + 2u64 => { + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = result.output.try_into().unwrap(); __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = result.output.try_into().unwrap(); __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(6); + break '__mc_0 [__v_9, __v_10]; + }, + 3u64 => { + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = result.output.try_into().unwrap(); __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_7 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(5); + break '__mc_0 [__v_9, __v_10]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, +} + }; + let __v_6: G = __mc_out___mc_0[0]; + let __v_7: G = __mc_out___mc_0[1]; + if (__v_2 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = result.output.try_into().unwrap(); __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + if (__v_9 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + let __ret: [G; OUT_653] = []; + record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_654: usize = 3; +const IN_654: usize = 3; +const OUT_654: usize = 1; +fn aiur_fn_654( + inp: [G; IN_654], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_654], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_654] = [__v_4]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_2 + __v_8); + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = result.output.try_into().unwrap(); __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_654] = [__v_10]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_654] = [__v_8]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_655: usize = 3; +const IN_655: usize = 3; +const OUT_655: usize = 0; +fn aiur_fn_655( + inp: [G; IN_655], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_655], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = result.output.try_into().unwrap(); __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = result.output.try_into().unwrap(); __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_656: usize = 4; +const IN_656: usize = 4; +const OUT_656: usize = 0; +fn aiur_fn_656( + inp: [G; IN_656], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_656], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = result.output.try_into().unwrap(); __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_657: usize = 1; +const IN_657: usize = 1; +const OUT_657: usize = 3; +fn aiur_fn_657( + inp: [G; IN_657], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_657], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_657] = [__v_3, __v_4, __v_2]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_657] = [__v_5, __v_3, __v_4]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 10; +fn aiur_fn_658( + inp: [G; IN_658], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_658], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_658] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_658] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_659: usize = 2; +const IN_659: usize = 2; +const OUT_659: usize = 3; +fn aiur_fn_659( + inp: [G; IN_659], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_659], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_659] = [__v_2, __v_3, __v_1]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_659] = [__v_4, __v_2, __v_3]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_660: usize = 2; +const IN_660: usize = 2; +const OUT_660: usize = 3; +fn aiur_fn_660( + inp: [G; IN_660], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_660], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_660] = [__v_2, __v_3, __v_1]; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_660] = [__v_4, __v_2, __v_3]; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_661: usize = 2; +const IN_661: usize = 2; +const OUT_661: usize = 3; +fn aiur_fn_661( + inp: [G; IN_661], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_661], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_661] = [__v_2, __v_3, __v_1]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(2); + let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_662: usize = 2; +const IN_662: usize = 2; +const OUT_662: usize = 3; +fn aiur_fn_662( + inp: [G; IN_662], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_662], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_662] = [__v_2, __v_3, __v_1]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(2); + let __ret: [G; OUT_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(3); + let __ret: [G; OUT_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_663: usize = 9; +const IN_663: usize = 9; +const OUT_663: usize = 2; +fn aiur_fn_663( + inp: [G; IN_663], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_663], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_663] = [__v_12, __v_0]; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = result.output.try_into().unwrap(); __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = result.output.try_into().unwrap(); __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_663] = [__v_39, __v_37]; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_664: usize = 2; +const IN_664: usize = 2; +const OUT_664: usize = 3; +fn aiur_fn_664( + inp: [G; IN_664], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_664], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_664] = [__v_2, __v_3, __v_1]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = result.output.try_into().unwrap(); __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_664] = [__v_13, __v_11, __v_12]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_665: usize = 1; +const IN_665: usize = 1; +const OUT_665: usize = 41; +fn aiur_fn_665( + inp: [G; IN_665], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_665], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_10: G = __b1_out[0]; + let __v_11: G = __b1_out[1]; + let __v_12: G = __b1_out[2]; + let __v_13: G = __b1_out[3]; + let __v_14: G = __b1_out[4]; + let __v_15: G = __b1_out[5]; + let __v_16: G = __b1_out[6]; + let __v_17: G = __b1_out[7]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = __r_arr[3]; + let __v_45: G = __r_arr[4]; + let __v_46: G = __r_arr[5]; + let __v_47: G = __r_arr[6]; + let __v_48: G = __r_arr[7]; + let __v_49: G = __r_arr[8]; + let __v_50: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __v_53: G = __r_arr[2]; + let __v_54: G = __r_arr[3]; + let __v_55: G = __r_arr[4]; + let __v_56: G = __r_arr[5]; + let __v_57: G = __r_arr[6]; + let __v_58: G = __r_arr[7]; + let __v_59: G = __r_arr[8]; + let __v_60: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_665] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_666: usize = 1; +const IN_666: usize = 1; +const OUT_666: usize = 49; +fn aiur_fn_666( + inp: [G; IN_666], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_666], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = result.output.try_into().unwrap(); __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __ret: [G; OUT_666] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_667: usize = 9; +const IN_667: usize = 9; +const OUT_667: usize = 2; +fn aiur_fn_667( + inp: [G; IN_667], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_667], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_667] = [__v_12, __v_0]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = result.output.try_into().unwrap(); __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __v_56: G = __r_arr[46]; + let __v_57: G = __r_arr[47]; + let __v_58: G = __r_arr[48]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __v_62: G = __r_arr[3]; + let __v_63: G = __r_arr[4]; + let __v_64: G = __r_arr[5]; + let __v_65: G = __r_arr[6]; + let __v_66: G = __r_arr[7]; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = result.output.try_into().unwrap(); __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_667] = [__v_70, __v_68]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_668: usize = 2; +const IN_668: usize = 2; +const OUT_668: usize = 3; +fn aiur_fn_668( + inp: [G; IN_668], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_668], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_668] = [__v_2, __v_3, __v_1]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = result.output.try_into().unwrap(); __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_668] = [__v_13, __v_11, __v_12]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_669: usize = 1; +const IN_669: usize = 1; +const OUT_669: usize = 55; +fn aiur_fn_669( + inp: [G; IN_669], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_669], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_3]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_3).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_12: G = __b1_out[0]; + let __v_13: G = __b1_out[1]; + let __v_14: G = __b1_out[2]; + let __v_15: G = __b1_out[3]; + let __v_16: G = __b1_out[4]; + let __v_17: G = __b1_out[5]; + let __v_18: G = __b1_out[6]; + let __v_19: G = __b1_out[7]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_4]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_4).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_20: G = __b1_out[0]; + let __v_21: G = __b1_out[1]; + let __v_22: G = __b1_out[2]; + let __v_23: G = __b1_out[3]; + let __v_24: G = __b1_out[4]; + let __v_25: G = __b1_out[5]; + let __v_26: G = __b1_out[6]; + let __v_27: G = __b1_out[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __ret: [G; OUT_669] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __v_65: G = __r_arr[8]; + let __v_66: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = __r_arr[2]; + let __v_70: G = __r_arr[3]; + let __v_71: G = __r_arr[4]; + let __v_72: G = __r_arr[5]; + let __v_73: G = __r_arr[6]; + let __v_74: G = __r_arr[7]; + let __v_75: G = __r_arr[8]; + let __v_76: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = __r_arr[1]; + let __v_79: G = __r_arr[2]; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_20, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = result.output.try_into().unwrap(); __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __v_81: G = __r_arr[1]; + let __v_82: G = __r_arr[2]; + let __v_83: G = G::from_u64(1); + let __v_84: G = G::from_u64(0); + let __ret: [G; OUT_669] = [__v_83, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_77, __v_78, __v_80, __v_81, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_82]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + let __v_61: G = __r_arr[7]; + let __v_62: G = __r_arr[8]; + let __v_63: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __v_70: G = __r_arr[6]; + let __v_71: G = __r_arr[7]; + let __v_72: G = __r_arr[8]; + let __v_73: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + let __v_81: G = __r_arr[7]; + let __v_82: G = __r_arr[8]; + let __v_83: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = result.output.try_into().unwrap(); __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __v_87: G = __r_arr[0]; + let __v_88: G = __r_arr[1]; + let __v_89: G = __r_arr[2]; + let __v_90: G = G::from_u64(2); + let __ret: [G; OUT_669] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_670: usize = 1; +const IN_670: usize = 1; +const OUT_670: usize = 63; +fn aiur_fn_670( + inp: [G; IN_670], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_670], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = result.output.try_into().unwrap(); __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __v_56: G = __r_arr[46]; + let __v_57: G = __r_arr[47]; + let __v_58: G = __r_arr[48]; + let __v_59: G = __r_arr[49]; + let __v_60: G = __r_arr[50]; + let __v_61: G = __r_arr[51]; + let __v_62: G = __r_arr[52]; + let __v_63: G = __r_arr[53]; + let __v_64: G = __r_arr[54]; + let __ret: [G; OUT_670] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_671: usize = 9; +const IN_671: usize = 9; +const OUT_671: usize = 2; +fn aiur_fn_671( + inp: [G; IN_671], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_671], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_671] = [__v_12, __v_0]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = result.output.try_into().unwrap(); __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __v_56: G = __r_arr[46]; + let __v_57: G = __r_arr[47]; + let __v_58: G = __r_arr[48]; + let __v_59: G = __r_arr[49]; + let __v_60: G = __r_arr[50]; + let __v_61: G = __r_arr[51]; + let __v_62: G = __r_arr[52]; + let __v_63: G = __r_arr[53]; + let __v_64: G = __r_arr[54]; + let __v_65: G = __r_arr[55]; + let __v_66: G = __r_arr[56]; + let __v_67: G = __r_arr[57]; + let __v_68: G = __r_arr[58]; + let __v_69: G = __r_arr[59]; + let __v_70: G = __r_arr[60]; + let __v_71: G = __r_arr[61]; + let __v_72: G = __r_arr[62]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = __r_arr[1]; + let __v_75: G = __r_arr[2]; + let __v_76: G = __r_arr[3]; + let __v_77: G = __r_arr[4]; + let __v_78: G = __r_arr[5]; + let __v_79: G = __r_arr[6]; + let __v_80: G = __r_arr[7]; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = result.output.try_into().unwrap(); __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __v_82: G = __r_arr[1]; + let __v_83: G = G::from_u64(0); + let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_671] = [__v_84, __v_82]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_672: usize = 1; +const IN_672: usize = 1; +const OUT_672: usize = 55; +fn aiur_fn_672( + inp: [G; IN_672], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_672], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_3]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_3).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_12: G = __b1_out[0]; + let __v_13: G = __b1_out[1]; + let __v_14: G = __b1_out[2]; + let __v_15: G = __b1_out[3]; + let __v_16: G = __b1_out[4]; + let __v_17: G = __b1_out[5]; + let __v_18: G = __b1_out[6]; + let __v_19: G = __b1_out[7]; + let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_4]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_4).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __v_20: G = __b1_out[0]; + let __v_21: G = __b1_out[1]; + let __v_22: G = __b1_out[2]; + let __v_23: G = __b1_out[3]; + let __v_24: G = __b1_out[4]; + let __v_25: G = __b1_out[5]; + let __v_26: G = __b1_out[6]; + let __v_27: G = __b1_out[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + let __v_61: G = __r_arr[7]; + let __v_62: G = __r_arr[8]; + let __v_63: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __v_70: G = __r_arr[6]; + let __v_71: G = __r_arr[7]; + let __v_72: G = __r_arr[8]; + let __v_73: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + let __v_81: G = __r_arr[7]; + let __v_82: G = __r_arr[8]; + let __v_83: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = result.output.try_into().unwrap(); __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __v_87: G = __r_arr[0]; + let __v_88: G = __r_arr[1]; + let __v_89: G = __r_arr[2]; + let __v_90: G = G::from_u64(1); + let __ret: [G; OUT_672] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = G::from_u64(2); + let __v_45: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = result.output.try_into().unwrap(); __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = G::from_u64(3); + let __v_45: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __v_47: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __v_51: G = G::from_u64(4); + let __v_52: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = G::from_u64(5); + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = G::from_u64(6); + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = G::from_u64(7); + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_30, __v_11]; + }, + 1u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = result.output.try_into().unwrap(); __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + break '__mc_0 [__v_37, __v_38]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + let __v_28: G = __mc_out___mc_0[0]; + let __v_29: G = __mc_out___mc_0[1]; + let __v_30: G = G::from_u64(8); + let __v_31: G = G::from_u64(0); + let __ret: [G; OUT_672] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_673: usize = 1; +const IN_673: usize = 1; +const OUT_673: usize = 57; +fn aiur_fn_673( + inp: [G; IN_673], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_673], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __v_10: G = __r_arr[9]; + let __v_11: G = G::from_u64(14); + if (__v_1 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + match __v_2.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_19, __v_12, __v_14, __v_16, __v_17, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_18]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(2); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = result.output.try_into().unwrap(); __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = __r_arr[3]; + let __v_18: G = __r_arr[4]; + let __v_19: G = __r_arr[5]; + let __v_20: G = __r_arr[6]; + let __v_21: G = __r_arr[7]; + let __v_22: G = __r_arr[8]; + let __v_23: G = __r_arr[9]; + let __v_24: G = __r_arr[10]; + let __v_25: G = __r_arr[11]; + let __v_26: G = __r_arr[12]; + let __v_27: G = __r_arr[13]; + let __v_28: G = __r_arr[14]; + let __v_29: G = __r_arr[15]; + let __v_30: G = __r_arr[16]; + let __v_31: G = __r_arr[17]; + let __v_32: G = __r_arr[18]; + let __v_33: G = __r_arr[19]; + let __v_34: G = __r_arr[20]; + let __v_35: G = __r_arr[21]; + let __v_36: G = __r_arr[22]; + let __v_37: G = __r_arr[23]; + let __v_38: G = __r_arr[24]; + let __v_39: G = __r_arr[25]; + let __v_40: G = __r_arr[26]; + let __v_41: G = __r_arr[27]; + let __v_42: G = __r_arr[28]; + let __v_43: G = __r_arr[29]; + let __v_44: G = __r_arr[30]; + let __v_45: G = __r_arr[31]; + let __v_46: G = __r_arr[32]; + let __v_47: G = __r_arr[33]; + let __v_48: G = __r_arr[34]; + let __v_49: G = __r_arr[35]; + let __v_50: G = __r_arr[36]; + let __v_51: G = __r_arr[37]; + let __v_52: G = __r_arr[38]; + let __v_53: G = __r_arr[39]; + let __v_54: G = __r_arr[40]; + let __v_55: G = __r_arr[41]; + let __v_56: G = __r_arr[42]; + let __v_57: G = __r_arr[43]; + let __v_58: G = __r_arr[44]; + let __v_59: G = __r_arr[45]; + let __v_60: G = __r_arr[46]; + let __v_61: G = __r_arr[47]; + let __v_62: G = __r_arr[48]; + let __v_63: G = __r_arr[49]; + let __v_64: G = __r_arr[50]; + let __v_65: G = __r_arr[51]; + let __v_66: G = __r_arr[52]; + let __v_67: G = __r_arr[53]; + let __v_68: G = __r_arr[54]; + let __v_69: G = G::from_u64(3); + let __ret: [G; OUT_673] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = G::from_u64(4); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_16, __v_12, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_674: usize = 32; +const IN_674: usize = 32; +const OUT_674: usize = 56; +fn aiur_fn_674( + inp: [G; IN_674], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_674], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __info = io_buffer.get_info(__v_32, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_33: G = __io_pair.0; + let __v_34: G = __io_pair.1; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = result.output.try_into().unwrap(); __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = __r_arr[19]; + let __v_57: G = __r_arr[20]; + let __v_58: G = __r_arr[21]; + let __v_59: G = __r_arr[22]; + let __v_60: G = __r_arr[23]; + let __v_61: G = __r_arr[24]; + let __v_62: G = __r_arr[25]; + let __v_63: G = __r_arr[26]; + let __v_64: G = __r_arr[27]; + let __v_65: G = __r_arr[28]; + let __v_66: G = __r_arr[29]; + let __v_67: G = __r_arr[30]; + let __v_68: G = __r_arr[31]; + let __v_69: G = __r_arr[32]; + let __v_70: G = __r_arr[33]; + let __v_71: G = __r_arr[34]; + let __v_72: G = __r_arr[35]; + let __v_73: G = __r_arr[36]; + let __v_74: G = __r_arr[37]; + let __v_75: G = __r_arr[38]; + let __v_76: G = __r_arr[39]; + let __v_77: G = __r_arr[40]; + let __v_78: G = __r_arr[41]; + let __v_79: G = __r_arr[42]; + let __v_80: G = __r_arr[43]; + let __v_81: G = __r_arr[44]; + let __v_82: G = __r_arr[45]; + let __v_83: G = __r_arr[46]; + let __v_84: G = __r_arr[47]; + let __v_85: G = __r_arr[48]; + let __v_86: G = __r_arr[49]; + let __v_87: G = __r_arr[50]; + let __v_88: G = __r_arr[51]; + let __v_89: G = __r_arr[52]; + let __v_90: G = __r_arr[53]; + let __v_91: G = __r_arr[54]; + let __v_92: G = __r_arr[55]; + let __v_93: G = __r_arr[56]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_94: G = __loaded[0]; + let __v_95: G = __loaded[1]; + let __v_96: G = __loaded[2]; + let __v_97: G = G::from_u64(1); + let __v_98: G = G::from_u64(1); + if (__v_94 != __v_97) { + return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_97.as_canonical_u64() }); + } + if (__v_95 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + if (__v_96 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + let __ret: [G; OUT_674] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_675: usize = 1; +const IN_675: usize = 1; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_675], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_675] = [__v_23]; + record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_676: usize = 1; +const IN_676: usize = 1; +const OUT_676: usize = 1; +fn aiur_fn_676( + inp: [G; IN_676], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_676], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_1: G = G::from_u64(2); + let __ret: [G; OUT_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_677: usize = 3; +const IN_677: usize = 3; +const OUT_677: usize = 0; +fn aiur_fn_677( + inp: [G; IN_677], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_677], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_677] = []; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = result.output.try_into().unwrap(); __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = result.output.try_into().unwrap(); __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_677] = []; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_678: usize = 3; +const IN_678: usize = 3; +const OUT_678: usize = 0; +fn aiur_fn_678( + inp: [G; IN_678], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_678], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_678] = []; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_678] = []; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_679: usize = 3; +const IN_679: usize = 3; +const OUT_679: usize = 0; +fn aiur_fn_679( + inp: [G; IN_679], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_679], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_679] = []; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + if (__v_0 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __ret: [G; OUT_679] = []; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_680: usize = 17; +const IN_680: usize = 17; +const OUT_680: usize = 0; +fn aiur_fn_680( + inp: [G; IN_680], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_680], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_680] = []; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + if (__v_0 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_1 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_2 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_3 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_4 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_5 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_6 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_7 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __ret: [G; OUT_680] = []; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_681: usize = 3; +const IN_681: usize = 3; +const OUT_681: usize = 0; +fn aiur_fn_681( + inp: [G; IN_681], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_681], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_681] = []; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + let __v_14: G = __loaded[11]; + let __v_15: G = __loaded[12]; + let __v_16: G = __loaded[13]; + let __v_17: G = __loaded[14]; + let __v_18: G = __loaded[15]; + let __v_19: G = __loaded[16]; + let __v_20: G = __loaded[17]; + let __v_21: G = __loaded[18]; + let __v_22: G = __loaded[19]; + let __v_23: G = __loaded[20]; + let __v_24: G = __loaded[21]; + let __v_25: G = __loaded[22]; + let __v_26: G = __loaded[23]; + let __v_27: G = __loaded[24]; + let __v_28: G = __loaded[25]; + let __v_29: G = __loaded[26]; + let __v_30: G = __loaded[27]; + let __v_31: G = __loaded[28]; + let __v_32: G = __loaded[29]; + let __v_33: G = __loaded[30]; + let __v_34: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + let __v_46: G = __loaded[11]; + let __v_47: G = __loaded[12]; + let __v_48: G = __loaded[13]; + let __v_49: G = __loaded[14]; + let __v_50: G = __loaded[15]; + let __v_51: G = __loaded[16]; + let __v_52: G = __loaded[17]; + let __v_53: G = __loaded[18]; + let __v_54: G = __loaded[19]; + let __v_55: G = __loaded[20]; + let __v_56: G = __loaded[21]; + let __v_57: G = __loaded[22]; + let __v_58: G = __loaded[23]; + let __v_59: G = __loaded[24]; + let __v_60: G = __loaded[25]; + let __v_61: G = __loaded[26]; + let __v_62: G = __loaded[27]; + let __v_63: G = __loaded[28]; + let __v_64: G = __loaded[29]; + let __v_65: G = __loaded[30]; + let __v_66: G = __loaded[31]; + if (__v_3 != __v_35) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64() }); + } + if (__v_4 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + if (__v_5 != __v_37) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() }); + } + if (__v_6 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + if (__v_7 != __v_39) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() }); + } + if (__v_8 != __v_40) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() }); + } + if (__v_9 != __v_41) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() }); + } + if (__v_10 != __v_42) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() }); + } + if (__v_11 != __v_43) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() }); + } + if (__v_12 != __v_44) { + return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() }); + } + if (__v_13 != __v_45) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() }); + } + if (__v_14 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + if (__v_15 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + if (__v_16 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + if (__v_17 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + if (__v_18 != __v_50) { + return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() }); + } + if (__v_19 != __v_51) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() }); + } + if (__v_20 != __v_52) { + return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() }); + } + if (__v_21 != __v_53) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() }); + } + if (__v_22 != __v_54) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() }); + } + if (__v_23 != __v_55) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); + } + if (__v_24 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_25 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_26 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + if (__v_27 != __v_59) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() }); + } + if (__v_28 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_29 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_30 != __v_62) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() }); + } + if (__v_31 != __v_63) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() }); + } + if (__v_32 != __v_64) { + return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() }); + } + if (__v_33 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + if (__v_34 != __v_66) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); + } + let __ret: [G; OUT_681] = []; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_682: usize = 3; +const IN_682: usize = 3; +const OUT_682: usize = 0; +fn aiur_fn_682( + inp: [G; IN_682], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_682], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_682] = []; + record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = result.output.try_into().unwrap(); __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + let __v_15: G = __loaded[11]; + let __v_16: G = __loaded[12]; + let __v_17: G = __loaded[13]; + let __v_18: G = __loaded[14]; + let __v_19: G = __loaded[15]; + let __v_20: G = __loaded[16]; + let __v_21: G = __loaded[17]; + let __v_22: G = __loaded[18]; + let __v_23: G = __loaded[19]; + let __v_24: G = __loaded[20]; + let __v_25: G = __loaded[21]; + let __v_26: G = __loaded[22]; + let __v_27: G = __loaded[23]; + let __v_28: G = __loaded[24]; + let __v_29: G = __loaded[25]; + let __v_30: G = __loaded[26]; + let __v_31: G = __loaded[27]; + let __v_32: G = __loaded[28]; + let __v_33: G = __loaded[29]; + let __v_34: G = __loaded[30]; + let __v_35: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_36: G = __loaded[0]; + let __v_37: G = __loaded[1]; + let __v_38: G = __loaded[2]; + let __v_39: G = __loaded[3]; + let __v_40: G = __loaded[4]; + let __v_41: G = __loaded[5]; + let __v_42: G = __loaded[6]; + let __v_43: G = __loaded[7]; + let __v_44: G = __loaded[8]; + let __v_45: G = __loaded[9]; + let __v_46: G = __loaded[10]; + let __v_47: G = __loaded[11]; + let __v_48: G = __loaded[12]; + let __v_49: G = __loaded[13]; + let __v_50: G = __loaded[14]; + let __v_51: G = __loaded[15]; + let __v_52: G = __loaded[16]; + let __v_53: G = __loaded[17]; + let __v_54: G = __loaded[18]; + let __v_55: G = __loaded[19]; + let __v_56: G = __loaded[20]; + let __v_57: G = __loaded[21]; + let __v_58: G = __loaded[22]; + let __v_59: G = __loaded[23]; + let __v_60: G = __loaded[24]; + let __v_61: G = __loaded[25]; + let __v_62: G = __loaded[26]; + let __v_63: G = __loaded[27]; + let __v_64: G = __loaded[28]; + let __v_65: G = __loaded[29]; + let __v_66: G = __loaded[30]; + let __v_67: G = __loaded[31]; + if (__v_4 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + if (__v_5 != __v_37) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() }); + } + if (__v_6 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + if (__v_7 != __v_39) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() }); + } + if (__v_8 != __v_40) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() }); + } + if (__v_9 != __v_41) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() }); + } + if (__v_10 != __v_42) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() }); + } + if (__v_11 != __v_43) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() }); + } + if (__v_12 != __v_44) { + return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() }); + } + if (__v_13 != __v_45) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() }); + } + if (__v_14 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + if (__v_15 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + if (__v_16 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + if (__v_17 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + if (__v_18 != __v_50) { + return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() }); + } + if (__v_19 != __v_51) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() }); + } + if (__v_20 != __v_52) { + return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() }); + } + if (__v_21 != __v_53) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() }); + } + if (__v_22 != __v_54) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() }); + } + if (__v_23 != __v_55) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); + } + if (__v_24 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_25 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_26 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + if (__v_27 != __v_59) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() }); + } + if (__v_28 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_29 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_30 != __v_62) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() }); + } + if (__v_31 != __v_63) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() }); + } + if (__v_32 != __v_64) { + return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() }); + } + if (__v_33 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + if (__v_34 != __v_66) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); + } + if (__v_35 != __v_67) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); + } + let __ret: [G; OUT_682] = []; + record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_683: usize = 2; +const IN_683: usize = 2; +const OUT_683: usize = 0; +fn aiur_fn_683( + inp: [G; IN_683], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_683], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_683] = []; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + match __v_22.as_canonical_u64() { + _ => { + if (__v_22 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_23 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_24 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_25 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_26 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_27 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_28 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_29 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_32, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_31, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = result.output.try_into().unwrap(); __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_683] = []; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_684: usize = 3; +const IN_684: usize = 3; +const OUT_684: usize = 0; +fn aiur_fn_684( + inp: [G; IN_684], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_684], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = result.output.try_into().unwrap(); __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_685: usize = 49; +const IN_685: usize = 49; +const OUT_685: usize = 0; +fn aiur_fn_685( + inp: [G; IN_685], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_685], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = result.output.try_into().unwrap(); __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = __r_arr[2]; + let __v_52: G = __r_arr[3]; + let __v_53: G = __r_arr[4]; + let __v_54: G = __r_arr[5]; + let __v_55: G = __r_arr[6]; + let __v_56: G = __r_arr[7]; + let __v_57: G = __r_arr[8]; + let __v_58: G = __r_arr[9]; + let __v_59: G = __r_arr[10]; + let __v_60: G = __r_arr[11]; + let __v_61: G = __r_arr[12]; + let __v_62: G = __r_arr[13]; + let __v_63: G = __r_arr[14]; + let __v_64: G = __r_arr[15]; + let __v_65: G = __r_arr[16]; + let __v_66: G = __r_arr[17]; + let __v_67: G = __r_arr[18]; + let __v_68: G = __r_arr[19]; + let __v_69: G = __r_arr[20]; + let __v_70: G = __r_arr[21]; + let __v_71: G = __r_arr[22]; + let __v_72: G = __r_arr[23]; + let __v_73: G = __r_arr[24]; + let __v_74: G = __r_arr[25]; + let __v_75: G = __r_arr[26]; + let __v_76: G = __r_arr[27]; + let __v_77: G = __r_arr[28]; + let __v_78: G = __r_arr[29]; + let __v_79: G = __r_arr[30]; + let __v_80: G = __r_arr[31]; + let __v_81: G = __r_arr[32]; + let __v_82: G = __r_arr[33]; + match __v_9.as_canonical_u64() { + _ => { + match __v_49.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_49, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_82, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_685] = []; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_686: usize = 2; +const IN_686: usize = 2; +const OUT_686: usize = 0; +fn aiur_fn_686( + inp: [G; IN_686], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_686], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + let __v_49: G = __loaded[47]; + let __v_50: G = __loaded[48]; + let __v_51: G = __loaded[49]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_686] = []; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = result.output.try_into().unwrap(); __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = result.output.try_into().unwrap(); __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_686] = []; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_687: usize = 3; +const IN_687: usize = 3; +const OUT_687: usize = 0; +fn aiur_fn_687( + inp: [G; IN_687], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_687], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = result.output.try_into().unwrap(); __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_688: usize = 99; +const IN_688: usize = 99; +const OUT_688: usize = 0; +fn aiur_fn_688( + inp: [G; IN_688], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_688], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_45.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_11, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_12, __v_61, __v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_45.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_3, __v_50, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_36, __v_88, __v_89]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_37, __v_90, __v_91]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = result.output.try_into().unwrap(); __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_45.as_canonical_u64() { + 2u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_43, __v_95, __v_96]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_44, __v_97, __v_98]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = result.output.try_into().unwrap(); __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_689: usize = 2; +const IN_689: usize = 2; +const OUT_689: usize = 0; +fn aiur_fn_689( + inp: [G; IN_689], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_689], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + let __v_49: G = __loaded[47]; + let __v_50: G = __loaded[48]; + let __v_51: G = __loaded[49]; + let __v_52: G = __loaded[50]; + let __v_53: G = __loaded[51]; + let __v_54: G = __loaded[52]; + let __v_55: G = __loaded[53]; + let __v_56: G = __loaded[54]; + let __v_57: G = __loaded[55]; + let __v_58: G = __loaded[56]; + let __v_59: G = __loaded[57]; + let __v_60: G = __loaded[58]; + let __v_61: G = __loaded[59]; + let __v_62: G = __loaded[60]; + let __v_63: G = __loaded[61]; + let __v_64: G = __loaded[62]; + let __v_65: G = __loaded[63]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = result.output.try_into().unwrap(); __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __v_75: G = __r_arr[9]; + let __v_76: G = __r_arr[10]; + let __v_77: G = __r_arr[11]; + let __v_78: G = __r_arr[12]; + let __v_79: G = __r_arr[13]; + let __v_80: G = __r_arr[14]; + let __v_81: G = __r_arr[15]; + let __v_82: G = __r_arr[16]; + let __v_83: G = __r_arr[17]; + let __v_84: G = __r_arr[18]; + let __v_85: G = __r_arr[19]; + let __v_86: G = __r_arr[20]; + let __v_87: G = __r_arr[21]; + let __v_88: G = __r_arr[22]; + let __v_89: G = __r_arr[23]; + let __v_90: G = __r_arr[24]; + let __v_91: G = __r_arr[25]; + let __v_92: G = __r_arr[26]; + let __v_93: G = __r_arr[27]; + let __v_94: G = __r_arr[28]; + let __v_95: G = __r_arr[29]; + let __v_96: G = __r_arr[30]; + let __v_97: G = __r_arr[31]; + let __v_98: G = __r_arr[32]; + let __v_99: G = __r_arr[33]; + let __v_100: G = __r_arr[34]; + let __v_101: G = __r_arr[35]; + let __v_102: G = __r_arr[36]; + let __v_103: G = __r_arr[37]; + let __v_104: G = __r_arr[38]; + let __v_105: G = __r_arr[39]; + let __v_106: G = __r_arr[40]; + let __v_107: G = __r_arr[41]; + let __v_108: G = __r_arr[42]; + let __v_109: G = __r_arr[43]; + let __v_110: G = __r_arr[44]; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = result.output.try_into().unwrap(); __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = result.output.try_into().unwrap(); __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_690: usize = 1; +const IN_690: usize = 1; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_690], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_690] = [__v_8]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_691: usize = 2; +const IN_691: usize = 2; +const OUT_691: usize = 1; +fn aiur_fn_691( + inp: [G; IN_691], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_691], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_691] = [__v_10]; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_692: usize = 1; +const IN_692: usize = 1; +const OUT_692: usize = 3; +fn aiur_fn_692( + inp: [G; IN_692], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_692], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = result.output.try_into().unwrap(); __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_692] = [__v_5, __v_10, __v_4]; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_692] = [__v_35, __v_38, __v_2]; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = result.output.try_into().unwrap(); __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_692] = [__v_9, __v_10, __v_8]; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_693: usize = 1; +const IN_693: usize = 1; +const OUT_693: usize = 1; +fn aiur_fn_693( + inp: [G; IN_693], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_693], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(1); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(1); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __v_47: G = __r_arr[9]; + let __v_48: G = G::from_u64(14); + if (__v_38 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + let __v_49: G = G::from_u64(2); + if (__v_39 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __v_52: G = __r_arr[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_53: G = __loaded[0]; + let __v_54: G = __loaded[1]; + let __v_55: G = __loaded[2]; + let __v_56: G = G::from_u64(1); + let __v_57: G = G::from_u64(1); + if (__v_53 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_54 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_55 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_58: G = __loaded[0]; + let __v_59: G = __loaded[1]; + let __v_60: G = __loaded[2]; + let __v_61: G = __loaded[3]; + let __v_62: G = __loaded[4]; + let __v_63: G = __loaded[5]; + let __v_64: G = __loaded[6]; + let __v_65: G = __loaded[7]; + let __v_66: G = __loaded[8]; + let __v_67: G = __loaded[9]; + let __v_68: G = __loaded[10]; + let __v_69: G = __loaded[11]; + let __v_70: G = __loaded[12]; + let __v_71: G = __loaded[13]; + let __v_72: G = __loaded[14]; + let __v_73: G = __loaded[15]; + let __v_74: G = __loaded[16]; + let __v_75: G = __loaded[17]; + let __v_76: G = __loaded[18]; + let __v_77: G = __loaded[19]; + let __v_78: G = __loaded[20]; + let __v_79: G = __loaded[21]; + let __v_80: G = __loaded[22]; + let __v_81: G = __loaded[23]; + let __v_82: G = __loaded[24]; + let __v_83: G = __loaded[25]; + let __v_84: G = __loaded[26]; + let __v_85: G = __loaded[27]; + let __v_86: G = __loaded[28]; + let __v_87: G = __loaded[29]; + let __v_88: G = __loaded[30]; + let __v_89: G = __loaded[31]; + if (__v_58 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_1.as_canonical_u64() }); + } + if (__v_59 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + if (__v_60 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_3.as_canonical_u64() }); + } + if (__v_61 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + if (__v_62 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + if (__v_63 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + if (__v_64 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + if (__v_65 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + if (__v_66 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_67 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_68 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_69 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_70 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_71 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_72 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_73 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_74 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_75 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + if (__v_76 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + if (__v_77 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + if (__v_78 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + if (__v_79 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + if (__v_80 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + if (__v_81 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_24.as_canonical_u64() }); + } + if (__v_82 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); + } + if (__v_83 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + if (__v_84 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_27.as_canonical_u64() }); + } + if (__v_85 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_28.as_canonical_u64() }); + } + if (__v_86 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + if (__v_87 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_30.as_canonical_u64() }); + } + if (__v_88 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_31.as_canonical_u64() }); + } + if (__v_89 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __ret: [G; OUT_693] = [__v_51]; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_694: usize = 2; +const IN_694: usize = 2; +const OUT_694: usize = 1; +fn aiur_fn_694( + inp: [G; IN_694], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_694], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_694] = [__v_5]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_694] = [__v_6]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = result.output.try_into().unwrap(); __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_694] = [__v_6]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_695: usize = 1; +const IN_695: usize = 1; +const OUT_695: usize = 1; +fn aiur_fn_695( + inp: [G; IN_695], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_695], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(256); + let __v_34: G = (__v_2 * __v_33); + let __v_35: G = G::from_u64(65536); + let __v_36: G = (__v_3 * __v_35); + let __v_37: G = G::from_u64(16777216); + let __v_38: G = (__v_4 * __v_37); + let __v_39: G = (__v_36 + __v_38); + let __v_40: G = (__v_34 + __v_39); + let __v_41: G = (__v_1 + __v_40); + let __ret: [G; OUT_695] = [__v_41]; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_696: usize = 7; +const IN_696: usize = 7; +const OUT_696: usize = 6; +fn aiur_fn_696( + inp: [G; IN_696], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_696], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_696] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = result.output.try_into().unwrap(); __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = result.output.try_into().unwrap(); __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __ret: [G; OUT_696] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_697: usize = 7; +const IN_697: usize = 7; +const OUT_697: usize = 1; +fn aiur_fn_697( + inp: [G; IN_697], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_697], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = result.output.try_into().unwrap(); __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_41, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __ret: [G; OUT_697] = [__v_42]; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_698: usize = 4; +const IN_698: usize = 4; +const OUT_698: usize = 0; +fn aiur_fn_698( + inp: [G; IN_698], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_698], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = result.output.try_into().unwrap(); __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = result.output.try_into().unwrap(); __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_699: usize = 10; +const IN_699: usize = 10; +const OUT_699: usize = 0; +fn aiur_fn_699( + inp: [G; IN_699], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_699], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = result.output.try_into().unwrap(); __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_9 + __v_26); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_9 + __v_26); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_700: usize = 3; +const IN_700: usize = 3; +const OUT_700: usize = 0; +fn aiur_fn_700( + inp: [G; IN_700], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_700], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = result.output.try_into().unwrap(); __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = result.output.try_into().unwrap(); __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = result.output.try_into().unwrap(); __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 0; +fn aiur_fn_701( + inp: [G; IN_701], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_701], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = result.output.try_into().unwrap(); __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_701] = []; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_702: usize = 3; +const IN_702: usize = 3; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_702], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = result.output.try_into().unwrap(); __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = result.output.try_into().unwrap(); __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = result.output.try_into().unwrap(); __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_703: usize = 55; +const IN_703: usize = 55; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: [G; IN_703], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_703], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = __r_arr[2]; + let __v_58: G = __r_arr[3]; + let __v_59: G = __r_arr[4]; + let __v_60: G = __r_arr[5]; + let __v_61: G = __r_arr[6]; + let __v_62: G = __r_arr[7]; + let __v_63: G = __r_arr[8]; + let __v_64: G = __r_arr[9]; + let __v_65: G = __r_arr[10]; + let __v_66: G = __r_arr[11]; + let __v_67: G = __r_arr[12]; + let __v_68: G = __r_arr[13]; + let __v_69: G = __r_arr[14]; + let __v_70: G = __r_arr[15]; + let __v_71: G = __r_arr[16]; + let __v_72: G = __r_arr[17]; + let __v_73: G = __r_arr[18]; + let __v_74: G = __r_arr[19]; + let __v_75: G = __r_arr[20]; + let __v_76: G = __r_arr[21]; + let __v_77: G = __r_arr[22]; + let __v_78: G = __r_arr[23]; + let __v_79: G = __r_arr[24]; + let __v_80: G = __r_arr[25]; + let __v_81: G = __r_arr[26]; + let __v_82: G = __r_arr[27]; + let __v_83: G = __r_arr[28]; + let __v_84: G = __r_arr[29]; + let __v_85: G = __r_arr[30]; + let __v_86: G = __r_arr[31]; + let __v_87: G = __r_arr[32]; + let __v_88: G = __r_arr[33]; + let __v_89: G = __r_arr[34]; + let __v_90: G = __r_arr[35]; + let __v_91: G = __r_arr[36]; + let __v_92: G = __r_arr[37]; + let __v_93: G = __r_arr[38]; + let __v_94: G = __r_arr[39]; + let __v_95: G = __r_arr[40]; + let __v_96: G = __r_arr[41]; + let __v_97: G = __r_arr[42]; + let __v_98: G = __r_arr[43]; + let __v_99: G = __r_arr[44]; + let __v_100: G = __r_arr[45]; + let __v_101: G = __r_arr[46]; + let __v_102: G = __r_arr[47]; + match __v_55.as_canonical_u64() { + _ => { + match __v_55.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_57, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_66, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_67, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 1u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_57, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_98, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_99, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = result.output.try_into().unwrap(); __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_1.as_canonical_u64() { + 2u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_1.as_canonical_u64() { + 3u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = result.output.try_into().unwrap(); __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_1.as_canonical_u64() { + 4u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_72, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_1.as_canonical_u64() { + 5u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_1.as_canonical_u64() { + 6u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_1.as_canonical_u64() { + 7u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 8u64 => { + match __v_1.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = result.output.try_into().unwrap(); __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_704: usize = 4; +const IN_704: usize = 4; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: [G; IN_704], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_704], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + if (__v_4 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_705: usize = 32; +const IN_705: usize = 32; +const OUT_705: usize = 0; +fn aiur_fn_705( + inp: [G; IN_705], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_705], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = result.output.try_into().unwrap(); __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = __r_arr[3]; + let __v_36: G = __r_arr[4]; + let __v_37: G = __r_arr[5]; + let __v_38: G = __r_arr[6]; + let __v_39: G = __r_arr[7]; + let __v_40: G = __r_arr[8]; + let __v_41: G = __r_arr[9]; + let __v_42: G = __r_arr[10]; + let __v_43: G = __r_arr[11]; + let __v_44: G = __r_arr[12]; + let __v_45: G = __r_arr[13]; + let __v_46: G = __r_arr[14]; + let __v_47: G = __r_arr[15]; + let __v_48: G = __r_arr[16]; + let __v_49: G = __r_arr[17]; + let __v_50: G = __r_arr[18]; + let __v_51: G = __r_arr[19]; + let __v_52: G = __r_arr[20]; + let __v_53: G = __r_arr[21]; + let __v_54: G = __r_arr[22]; + let __v_55: G = __r_arr[23]; + let __v_56: G = __r_arr[24]; + let __v_57: G = __r_arr[25]; + let __v_58: G = __r_arr[26]; + let __v_59: G = __r_arr[27]; + let __v_60: G = __r_arr[28]; + let __v_61: G = __r_arr[29]; + let __v_62: G = __r_arr[30]; + let __v_63: G = __r_arr[31]; + let __v_64: G = __r_arr[32]; + let __v_65: G = __r_arr[33]; + let __v_66: G = __r_arr[34]; + let __v_67: G = __r_arr[35]; + let __v_68: G = __r_arr[36]; + let __v_69: G = __r_arr[37]; + let __v_70: G = __r_arr[38]; + let __v_71: G = __r_arr[39]; + let __v_72: G = __r_arr[40]; + let __v_73: G = __r_arr[41]; + let __v_74: G = __r_arr[42]; + let __v_75: G = __r_arr[43]; + let __v_76: G = __r_arr[44]; + let __v_77: G = __r_arr[45]; + let __v_78: G = __r_arr[46]; + let __v_79: G = __r_arr[47]; + let __v_80: G = __r_arr[48]; + let __v_81: G = __r_arr[49]; + let __v_82: G = __r_arr[50]; + let __v_83: G = __r_arr[51]; + let __v_84: G = __r_arr[52]; + let __v_85: G = __r_arr[53]; + let __v_86: G = __r_arr[54]; + let __v_87: G = __r_arr[55]; + match __v_32.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = result.output.try_into().unwrap(); __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = result.output.try_into().unwrap(); __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = result.output.try_into().unwrap(); __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = result.output.try_into().unwrap(); __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = result.output.try_into().unwrap(); __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_706: usize = 32; +const IN_706: usize = 32; +const OUT_706: usize = 0; +fn aiur_fn_706( + inp: [G; IN_706], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_706], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = result.output.try_into().unwrap(); __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_32, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_33, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_707: usize = 1; +const IN_707: usize = 1; +const OUT_707: usize = 0; +fn aiur_fn_707( + inp: [G; IN_707], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_707], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_1: G = G::from_u64(1); + let __v_2: G = (__v_0 - __v_1); + let __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = __r_arr[3]; + let __v_12: G = __r_arr[4]; + let __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + let __v_40: G = __r_arr[32]; + let __v_41: G = __r_arr[33]; + let __v_42: G = __r_arr[34]; + let __v_43: G = __r_arr[35]; + let __v_44: G = __r_arr[36]; + let __v_45: G = __r_arr[37]; + let __v_46: G = __r_arr[38]; + let __v_47: G = __r_arr[39]; + let __v_48: G = __r_arr[40]; + let __v_49: G = __r_arr[41]; + let __v_50: G = __r_arr[42]; + let __v_51: G = __r_arr[43]; + let __v_52: G = __r_arr[44]; + let __v_53: G = __r_arr[45]; + let __v_54: G = __r_arr[46]; + let __v_55: G = __r_arr[47]; + let __v_56: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + if (__v_57 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_58 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_59 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + if (__v_7 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = result.output.try_into().unwrap(); __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_708: usize = 0; +const IN_708: usize = 0; +const OUT_708: usize = 0; +fn aiur_fn_708( + inp: [G; IN_708], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_708], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(4); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(1); + if (__v_5 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + let __v_7: G = G::from_u64(4); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(4); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(1); + if (__v_13 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(4); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + if (__v_21 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(4); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 3] = [__v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(4); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 3] = [__v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_23, __v_27, __v_28, __v_29, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(1); + if (__v_35 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(4); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 3] = [__v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(4); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_37, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = G::from_u64(0); + if (__v_46 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + let __v_48: G = G::from_u64(4); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(1); + let __v_52: G = G::from_u64(4); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 3] = [__v_52, __v_53, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_48, __v_49, __v_50, __v_51, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(1); + if (__v_57 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + let __v_59: G = G::from_u64(2); + let __v_60: G = G::from_u64(4); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(4); + let __v_65: G = G::from_u64(1); + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 3] = [__v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = G::from_u64(1); + if (__v_68 != __v_69) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64() }); + } + let __v_70: G = G::from_u64(4); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_70, __v_71, __v_72, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = G::from_u64(1); + if (__v_73 != __v_74) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64() }); + } + let __v_75: G = G::from_u64(4); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_75, __v_76, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __v_79: G = G::from_u64(0); + if (__v_78 != __v_79) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64() }); + } + let __v_80: G = G::from_u64(3); + let __v_81: G = G::from_u64(4); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = { let __values: [G; 3] = [__v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = G::from_u64(4); + let __v_86: G = G::from_u64(1); + let __v_87: G = G::from_u64(0); + let __v_88: G = { let __values: [G; 3] = [__v_85, __v_86, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_80, __v_84, __v_88, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_89: G = __r_arr[0]; + let __v_90: G = G::from_u64(1); + if (__v_89 != __v_90) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64() }); + } + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_80, __v_84, __v_88]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = G::from_u64(0); + if (__v_91 != __v_92) { + return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64() }); + } + let __v_93: G = G::from_u64(1); + let __v_94: G = G::from_u64(4); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = { let __values: [G; 3] = [__v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(2); + let __v_100: G = G::from_u64(1); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_104: G = G::from_u64(0); + let __v_105: G = { let __values: [G; 3] = [__v_100, __v_103, __v_104]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = G::from_u64(3); + let __v_107: G = G::from_u64(1); + let __v_108: G = G::from_u64(4); + let __v_109: G = G::from_u64(0); + let __v_110: G = G::from_u64(0); + let __v_111: G = { let __values: [G; 3] = [__v_108, __v_109, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = G::from_u64(0); + let __v_113: G = { let __values: [G; 3] = [__v_107, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_114: G = G::from_u64(4); + let __v_115: G = G::from_u64(0); + let __v_116: G = G::from_u64(0); + let __v_117: G = { let __values: [G; 3] = [__v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_118: G = { let __values: [G; 3] = [__v_106, __v_113, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_93, __v_97, __v_98, __v_99, __v_105, __v_118]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_119: G = __r_arr[0]; + let __v_120: G = G::from_u64(1); + if (__v_119 != __v_120) { + return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_120.as_canonical_u64() }); + } + let __v_121: G = G::from_u64(3); + let __v_122: G = G::from_u64(4); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = { let __values: [G; 3] = [__v_122, __v_123, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_126: G = G::from_u64(4); + let __v_127: G = G::from_u64(0); + let __v_128: G = G::from_u64(0); + let __v_129: G = { let __values: [G; 3] = [__v_126, __v_127, __v_128]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_130: G = G::from_u64(4); + let __v_131: G = G::from_u64(0); + let __v_132: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_121, __v_125, __v_129, __v_130, __v_131, __v_132]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_133: G = __r_arr[0]; + let __v_134: G = G::from_u64(1); + if (__v_133 != __v_134) { + return Err(ExecError::AssertEqMismatch { lhs: __v_133.as_canonical_u64(), rhs: __v_134.as_canonical_u64() }); + } + let __v_135: G = G::from_u64(2); + let __v_136: G = G::from_u64(4); + let __v_137: G = G::from_u64(0); + let __v_138: G = G::from_u64(0); + let __v_139: G = { let __values: [G; 3] = [__v_136, __v_137, __v_138]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_140: G = G::from_u64(0); + let __v_141: G = G::from_u64(0); + let __v_142: G = { let __values: [G; 3] = [__v_140, __v_141, __v_141]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = G::from_u64(4); + let __v_144: G = G::from_u64(0); + let __v_145: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_135, __v_139, __v_142, __v_143, __v_144, __v_145]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_146: G = __r_arr[0]; + let __v_147: G = G::from_u64(1); + if (__v_146 != __v_147) { + return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_147.as_canonical_u64() }); + } + let __v_148: G = G::from_u64(1); + let __v_149: G = G::from_u64(4); + let __v_150: G = G::from_u64(1); + let __v_151: G = G::from_u64(0); + let __v_152: G = { let __values: [G; 3] = [__v_149, __v_150, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_153: G = G::from_u64(0); + let __v_154: G = G::from_u64(4); + let __v_155: G = G::from_u64(0); + let __v_156: G = G::from_u64(0); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_154, __v_155, __v_156, __v_148, __v_152, __v_153]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_157: G = __r_arr[0]; + let __v_158: G = __r_arr[1]; + let __v_159: G = __r_arr[2]; + let __v_160: G = G::from_u64(2); + let __v_161: G = G::from_u64(4); + let __v_162: G = G::from_u64(0); + let __v_163: G = G::from_u64(0); + let __v_164: G = { let __values: [G; 3] = [__v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_165: G = { let __values: [G; 3] = [__v_148, __v_152, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_157, __v_158, __v_159, __v_160, __v_164, __v_165]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_166: G = __r_arr[0]; + let __v_167: G = G::from_u64(1); + if (__v_166 != __v_167) { + return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_167.as_canonical_u64() }); + } + let __v_168: G = G::from_u64(4); + let __v_169: G = G::from_u64(0); + let __v_170: G = G::from_u64(0); + let __v_171: G = G::from_u64(0); + let __v_172: G = G::from_u64(0); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_168, __v_169, __v_170, __v_171, __v_172, __v_172]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_173: G = __r_arr[0]; + let __v_174: G = __r_arr[1]; + let __v_175: G = __r_arr[2]; + let __v_176: G = G::from_u64(0); + let __v_177: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_173, __v_174, __v_175, __v_176, __v_177, __v_177]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_178: G = __r_arr[0]; + let __v_179: G = G::from_u64(1); + if (__v_178 != __v_179) { + return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_179.as_canonical_u64() }); + } + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_709: usize = 0; +const IN_709: usize = 0; +const OUT_709: usize = 0; +fn aiur_fn_709( + inp: [G; IN_709], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_709], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = result.output.try_into().unwrap(); __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_710: usize = 1; +const IN_710: usize = 1; +const OUT_710: usize = 0; +fn aiur_fn_710( + inp: [G; IN_710], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_710], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_1: G = G::from_u64(1); + let __v_2: G = (__v_0 - __v_1); + let __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = __r_arr[3]; + let __v_12: G = __r_arr[4]; + let __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + let __v_40: G = __r_arr[32]; + let __v_41: G = __r_arr[33]; + let __v_42: G = __r_arr[34]; + let __v_43: G = __r_arr[35]; + let __v_44: G = __r_arr[36]; + let __v_45: G = __r_arr[37]; + let __v_46: G = __r_arr[38]; + let __v_47: G = __r_arr[39]; + let __v_48: G = __r_arr[40]; + let __v_49: G = __r_arr[41]; + let __v_50: G = __r_arr[42]; + let __v_51: G = __r_arr[43]; + let __v_52: G = __r_arr[44]; + let __v_53: G = __r_arr[45]; + let __v_54: G = __r_arr[46]; + let __v_55: G = __r_arr[47]; + let __v_56: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + if (__v_57 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_58 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_59 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __v_75: G = __r_arr[9]; + let __v_76: G = __r_arr[10]; + let __v_77: G = __r_arr[11]; + let __v_78: G = __r_arr[12]; + let __v_79: G = __r_arr[13]; + let __v_80: G = __r_arr[14]; + let __v_81: G = __r_arr[15]; + let __v_82: G = __r_arr[16]; + let __v_83: G = __r_arr[17]; + let __v_84: G = __r_arr[18]; + let __v_85: G = __r_arr[19]; + let __v_86: G = __r_arr[20]; + let __v_87: G = __r_arr[21]; + let __v_88: G = __r_arr[22]; + let __v_89: G = __r_arr[23]; + let __v_90: G = __r_arr[24]; + let __v_91: G = __r_arr[25]; + let __v_92: G = __r_arr[26]; + let __v_93: G = __r_arr[27]; + let __v_94: G = __r_arr[28]; + let __v_95: G = __r_arr[29]; + let __v_96: G = __r_arr[30]; + let __v_97: G = __r_arr[31]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_98: G = __r_arr[0]; + let __v_99: G = __r_arr[1]; + let __v_100: G = __r_arr[2]; + let __v_101: G = __r_arr[3]; + let __v_102: G = __r_arr[4]; + let __v_103: G = __r_arr[5]; + let __v_104: G = __r_arr[6]; + let __v_105: G = __r_arr[7]; + let __v_106: G = __r_arr[8]; + let __v_107: G = __r_arr[9]; + let __v_108: G = __r_arr[10]; + let __v_109: G = __r_arr[11]; + let __v_110: G = __r_arr[12]; + let __v_111: G = __r_arr[13]; + let __v_112: G = __r_arr[14]; + let __v_113: G = __r_arr[15]; + let __v_114: G = __r_arr[16]; + let __v_115: G = __r_arr[17]; + let __v_116: G = __r_arr[18]; + let __v_117: G = __r_arr[19]; + let __v_118: G = __r_arr[20]; + let __v_119: G = __r_arr[21]; + let __v_120: G = __r_arr[22]; + let __v_121: G = __r_arr[23]; + let __v_122: G = __r_arr[24]; + let __v_123: G = __r_arr[25]; + let __v_124: G = __r_arr[26]; + let __v_125: G = __r_arr[27]; + let __v_126: G = __r_arr[28]; + let __v_127: G = __r_arr[29]; + let __v_128: G = __r_arr[30]; + let __v_129: G = __r_arr[31]; + if (__v_66 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + if (__v_67 != __v_99) { + return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_99.as_canonical_u64() }); + } + if (__v_68 != __v_100) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_100.as_canonical_u64() }); + } + if (__v_69 != __v_101) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_101.as_canonical_u64() }); + } + if (__v_70 != __v_102) { + return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_102.as_canonical_u64() }); + } + if (__v_71 != __v_103) { + return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_103.as_canonical_u64() }); + } + if (__v_72 != __v_104) { + return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_104.as_canonical_u64() }); + } + if (__v_73 != __v_105) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_105.as_canonical_u64() }); + } + if (__v_74 != __v_106) { + return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_106.as_canonical_u64() }); + } + if (__v_75 != __v_107) { + return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_107.as_canonical_u64() }); + } + if (__v_76 != __v_108) { + return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_108.as_canonical_u64() }); + } + if (__v_77 != __v_109) { + return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_109.as_canonical_u64() }); + } + if (__v_78 != __v_110) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_110.as_canonical_u64() }); + } + if (__v_79 != __v_111) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_111.as_canonical_u64() }); + } + if (__v_80 != __v_112) { + return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_112.as_canonical_u64() }); + } + if (__v_81 != __v_113) { + return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_113.as_canonical_u64() }); + } + if (__v_82 != __v_114) { + return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_114.as_canonical_u64() }); + } + if (__v_83 != __v_115) { + return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_115.as_canonical_u64() }); + } + if (__v_84 != __v_116) { + return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_116.as_canonical_u64() }); + } + if (__v_85 != __v_117) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_117.as_canonical_u64() }); + } + if (__v_86 != __v_118) { + return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_118.as_canonical_u64() }); + } + if (__v_87 != __v_119) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_119.as_canonical_u64() }); + } + if (__v_88 != __v_120) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_120.as_canonical_u64() }); + } + if (__v_89 != __v_121) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_121.as_canonical_u64() }); + } + if (__v_90 != __v_122) { + return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_122.as_canonical_u64() }); + } + if (__v_91 != __v_123) { + return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_123.as_canonical_u64() }); + } + if (__v_92 != __v_124) { + return Err(ExecError::AssertEqMismatch { lhs: __v_92.as_canonical_u64(), rhs: __v_124.as_canonical_u64() }); + } + if (__v_93 != __v_125) { + return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_125.as_canonical_u64() }); + } + if (__v_94 != __v_126) { + return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_126.as_canonical_u64() }); + } + if (__v_95 != __v_127) { + return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_127.as_canonical_u64() }); + } + if (__v_96 != __v_128) { + return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_128.as_canonical_u64() }); + } + if (__v_97 != __v_129) { + return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() }); + } + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = result.output.try_into().unwrap(); __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_710] = []; + record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_711: usize = 2; +const IN_711: usize = 2; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: [G; IN_711], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_711], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_711] = [__v_9]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_711] = [__v_7]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 8; +fn aiur_fn_712( + inp: [G; IN_712], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_712], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_712] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __ret: [G; OUT_712] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_713: usize = 1; +const IN_713: usize = 1; +const OUT_713: usize = 8; +fn aiur_fn_713( + inp: [G; IN_713], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_713], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_713] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __ret: [G; OUT_713] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_714: usize = 2; +const IN_714: usize = 2; +const OUT_714: usize = 1; +fn aiur_fn_714( + inp: [G; IN_714], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_714], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_714] = [__v_1]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_714] = [__v_7]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_715: usize = 8; +const IN_715: usize = 8; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_715], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_715] = [__v_7]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_715] = [__v_21]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_0 - __v_3); + match __v_21.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_715] = [__v_4]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_715] = [__v_22]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 1; +fn aiur_fn_716( + inp: [G; IN_716], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_716], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = result.output.try_into().unwrap(); __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_716] = [__v_4]; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_717: usize = 1; +const IN_717: usize = 1; +const OUT_717: usize = 8; +fn aiur_fn_717( + inp: [G; IN_717], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_717], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __ret: [G; OUT_717] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = result.output.try_into().unwrap(); __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = __r_arr[4]; + let __v_50: G = __r_arr[5]; + let __v_51: G = __r_arr[6]; + let __v_52: G = __r_arr[7]; + let __ret: [G; OUT_717] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_718: usize = 2; +const IN_718: usize = 2; +const OUT_718: usize = 1; +fn aiur_fn_718( + inp: [G; IN_718], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_718], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_718] = [__v_4]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_719: usize = 1; +const IN_719: usize = 1; +const OUT_719: usize = 1; +fn aiur_fn_719( + inp: [G; IN_719], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_719], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_719] = [__v_7]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_7 + __v_8); + let __ret: [G; OUT_719] = [__v_9]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_720: usize = 9; +const IN_720: usize = 9; +const OUT_720: usize = 1; +fn aiur_fn_720( + inp: [G; IN_720], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_720], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_720] = [__v_10]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = __r_arr[3]; + let __v_17: G = __r_arr[4]; + let __v_18: G = __r_arr[5]; + let __v_19: G = __r_arr[6]; + let __v_20: G = __r_arr[7]; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_720] = [__v_21]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_721: usize = 1; +const IN_721: usize = 1; +const OUT_721: usize = 1; +fn aiur_fn_721( + inp: [G; IN_721], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_721], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_721] = [__v_11]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_11 + __v_12); + let __ret: [G; OUT_721] = [__v_13]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_722: usize = 7; +const IN_722: usize = 7; +const OUT_722: usize = 1; +fn aiur_fn_722( + inp: [G; IN_722], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_722], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_19.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_722] = [__v_20]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = (__v_0 - __v_3); + match __v_20.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_722] = [__v_4]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_722] = [__v_21]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_723: usize = 9; +const IN_723: usize = 9; +const OUT_723: usize = 45; +fn aiur_fn_723( + inp: [G; IN_723], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_723], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + let __v_45: G = __loaded[36]; + let __v_46: G = __loaded[37]; + let __v_47: G = __loaded[38]; + let __v_48: G = __loaded[39]; + let __v_49: G = __loaded[40]; + let __v_50: G = __loaded[41]; + let __v_51: G = __loaded[42]; + let __v_52: G = __loaded[43]; + let __v_53: G = __loaded[44]; + let __v_54: G = __loaded[45]; + let __v_55: G = __loaded[46]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + match __v_56.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_723] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = result.output.try_into().unwrap(); __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = __r_arr[1]; + let __v_67: G = __r_arr[2]; + let __v_68: G = __r_arr[3]; + let __v_69: G = __r_arr[4]; + let __v_70: G = __r_arr[5]; + let __v_71: G = __r_arr[6]; + let __v_72: G = __r_arr[7]; + let __v_73: G = __r_arr[8]; + let __v_74: G = __r_arr[9]; + let __v_75: G = __r_arr[10]; + let __v_76: G = __r_arr[11]; + let __v_77: G = __r_arr[12]; + let __v_78: G = __r_arr[13]; + let __v_79: G = __r_arr[14]; + let __v_80: G = __r_arr[15]; + let __v_81: G = __r_arr[16]; + let __v_82: G = __r_arr[17]; + let __v_83: G = __r_arr[18]; + let __v_84: G = __r_arr[19]; + let __v_85: G = __r_arr[20]; + let __v_86: G = __r_arr[21]; + let __v_87: G = __r_arr[22]; + let __v_88: G = __r_arr[23]; + let __v_89: G = __r_arr[24]; + let __v_90: G = __r_arr[25]; + let __v_91: G = __r_arr[26]; + let __v_92: G = __r_arr[27]; + let __v_93: G = __r_arr[28]; + let __v_94: G = __r_arr[29]; + let __v_95: G = __r_arr[30]; + let __v_96: G = __r_arr[31]; + let __v_97: G = __r_arr[32]; + let __v_98: G = __r_arr[33]; + let __v_99: G = __r_arr[34]; + let __v_100: G = __r_arr[35]; + let __v_101: G = __r_arr[36]; + let __v_102: G = __r_arr[37]; + let __v_103: G = __r_arr[38]; + let __v_104: G = __r_arr[39]; + let __v_105: G = __r_arr[40]; + let __v_106: G = __r_arr[41]; + let __v_107: G = __r_arr[42]; + let __v_108: G = __r_arr[43]; + let __v_109: G = __r_arr[44]; + let __ret: [G; OUT_723] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_724: usize = 2; +const IN_724: usize = 2; +const OUT_724: usize = 1; +fn aiur_fn_724( + inp: [G; IN_724], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_724], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_724] = [__v_1]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = result.output.try_into().unwrap(); __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_724] = [__v_10]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 8; +fn aiur_fn_725( + inp: [G; IN_725], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_725], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __ret: [G; OUT_725] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = result.output.try_into().unwrap(); __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __v_51: G = __r_arr[3]; + let __v_52: G = __r_arr[4]; + let __v_53: G = __r_arr[5]; + let __v_54: G = __r_arr[6]; + let __v_55: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = __r_arr[6]; + let __v_63: G = __r_arr[7]; + let __ret: [G; OUT_725] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_726: usize = 1; +const IN_726: usize = 1; +const OUT_726: usize = 8; +fn aiur_fn_726( + inp: [G; IN_726], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_726], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_726] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = result.output.try_into().unwrap(); __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __v_15: G = __r_arr[3]; + let __v_16: G = __r_arr[4]; + let __v_17: G = __r_arr[5]; + let __v_18: G = __r_arr[6]; + let __v_19: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __v_22: G = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __ret: [G; OUT_726] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 1; +fn aiur_fn_727( + inp: [G; IN_727], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_727], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_727] = [__v_1]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = result.output.try_into().unwrap(); __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_727] = [__v_8]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_728: usize = 9; +const IN_728: usize = 9; +const OUT_728: usize = 34; +fn aiur_fn_728( + inp: [G; IN_728], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_728], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + match __v_45.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_728] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = __r_arr[1]; + let __v_48: G = __r_arr[2]; + let __v_49: G = __r_arr[3]; + let __v_50: G = __r_arr[4]; + let __v_51: G = __r_arr[5]; + let __v_52: G = __r_arr[6]; + let __v_53: G = __r_arr[7]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = result.output.try_into().unwrap(); __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + let __v_61: G = __r_arr[7]; + let __v_62: G = __r_arr[8]; + let __v_63: G = __r_arr[9]; + let __v_64: G = __r_arr[10]; + let __v_65: G = __r_arr[11]; + let __v_66: G = __r_arr[12]; + let __v_67: G = __r_arr[13]; + let __v_68: G = __r_arr[14]; + let __v_69: G = __r_arr[15]; + let __v_70: G = __r_arr[16]; + let __v_71: G = __r_arr[17]; + let __v_72: G = __r_arr[18]; + let __v_73: G = __r_arr[19]; + let __v_74: G = __r_arr[20]; + let __v_75: G = __r_arr[21]; + let __v_76: G = __r_arr[22]; + let __v_77: G = __r_arr[23]; + let __v_78: G = __r_arr[24]; + let __v_79: G = __r_arr[25]; + let __v_80: G = __r_arr[26]; + let __v_81: G = __r_arr[27]; + let __v_82: G = __r_arr[28]; + let __v_83: G = __r_arr[29]; + let __v_84: G = __r_arr[30]; + let __v_85: G = __r_arr[31]; + let __v_86: G = __r_arr[32]; + let __v_87: G = __r_arr[33]; + let __ret: [G; OUT_728] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 1; +fn aiur_fn_729( + inp: [G; IN_729], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_729], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_730: usize = 2; +const IN_730: usize = 2; +const OUT_730: usize = 3; +fn aiur_fn_730( + inp: [G; IN_730], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_730], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = result.output.try_into().unwrap(); __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_730] = [__v_4, __v_5, __v_6]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +const OUT_731: usize = 1; +fn aiur_fn_731( + inp: [G; IN_731], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_731], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_731] = [__v_4]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_731] = [__v_9]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 1; +fn aiur_fn_732( + inp: [G; IN_732], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_732], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_37: G = G::from_u64(0); + let __ret: [G; OUT_732] = [__v_37]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(1); + let __v_39: G = (__v_37 + __v_38); + let __ret: [G; OUT_732] = [__v_39]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_733: usize = 2; +const IN_733: usize = 2; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_733], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_733] = [__v_0]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_733] = [__v_7]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_734: usize = 1; +const IN_734: usize = 1; +const OUT_734: usize = 1; +fn aiur_fn_734( + inp: [G; IN_734], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_734], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_734] = [__v_6]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_6 + __v_7); + let __ret: [G; OUT_734] = [__v_8]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_735: usize = 8; +const IN_735: usize = 8; +const OUT_735: usize = 6; +fn aiur_fn_735( + inp: [G; IN_735], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_735], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __v_11: G = __r_arr[3]; + let __v_12: G = __r_arr[4]; + let __v_13: G = __r_arr[5]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __ret: [G; OUT_735] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_736: usize = 2; +const IN_736: usize = 2; +const OUT_736: usize = 1; +fn aiur_fn_736( + inp: [G; IN_736], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_736], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_736] = [__v_1]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_6, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_736] = [__v_9]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_737: usize = 9; +const IN_737: usize = 9; +const OUT_737: usize = 1; +fn aiur_fn_737( + inp: [G; IN_737], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_737], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_737] = [__v_23]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_737] = [__v_21]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_738: usize = 2; +const IN_738: usize = 2; +const OUT_738: usize = 1; +fn aiur_fn_738( + inp: [G; IN_738], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_738], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_738] = [__v_1]; + record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = result.output.try_into().unwrap(); __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_738] = [__v_7]; + record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_739: usize = 2; +const IN_739: usize = 2; +const OUT_739: usize = 1; +fn aiur_fn_739( + inp: [G; IN_739], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_739], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_739] = [__v_0]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = result.output.try_into().unwrap(); __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_739] = [__v_9]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_740: usize = 8; +const IN_740: usize = 8; +const OUT_740: usize = 6; +fn aiur_fn_740( + inp: [G; IN_740], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_740], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_740] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __v_25: G = __r_arr[4]; + let __v_26: G = __r_arr[5]; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = result.output.try_into().unwrap(); __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = __r_arr[3]; + let __v_31: G = __r_arr[4]; + let __v_32: G = __r_arr[5]; + let __ret: [G; OUT_740] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_0 - __v_4); + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_740] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + let __v_24: G = __r_arr[2]; + let __v_25: G = __r_arr[3]; + let __v_26: G = __r_arr[4]; + let __v_27: G = __r_arr[5]; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = result.output.try_into().unwrap(); __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __ret: [G; OUT_740] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_741: usize = 15; +const IN_741: usize = 15; +const OUT_741: usize = 6; +fn aiur_fn_741( + inp: [G; IN_741], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_741], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = result.output.try_into().unwrap(); __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = __r_arr[3]; + let __v_19: G = __r_arr[4]; + let __v_20: G = __r_arr[5]; + let __ret: [G; OUT_741] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_741] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_742: usize = 14; +const IN_742: usize = 14; +const OUT_742: usize = 6; +fn aiur_fn_742( + inp: [G; IN_742], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_742], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(1); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(1); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +pub(crate) fn execute_generated( + fun_idx: usize, + args: &[G], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, +) -> Result, ExecError> { + match fun_idx as u64 { + 0u64 => { + let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_0(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 1u64 => { + let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_1(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 2u64 => { + let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_2(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 3u64 => { + let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_3(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 4u64 => { + let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_4(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 5u64 => { + let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_5(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 6u64 => { + let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_6(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 7u64 => { + let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_7(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 8u64 => { + let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_8(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 9u64 => { + let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_9(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 10u64 => { + let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_10(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 11u64 => { + let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_11(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 12u64 => { + let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_12(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 13u64 => { + let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_13(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 14u64 => { + let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_14(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 15u64 => { + let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_15(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 16u64 => { + let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_16(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 17u64 => { + let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_17(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 18u64 => { + let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_18(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 19u64 => { + let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_19(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 20u64 => { + let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_20(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 21u64 => { + let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_21(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 22u64 => { + let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_22(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 23u64 => { + let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_23(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 24u64 => { + let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_24(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 25u64 => { + let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_25(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 26u64 => { + let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_26(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 27u64 => { + let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_27(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 28u64 => { + let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_28(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 29u64 => { + let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_29(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 30u64 => { + let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_30(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 31u64 => { + let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_31(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 32u64 => { + let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_32(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 33u64 => { + let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_33(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 34u64 => { + let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_34(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 35u64 => { + let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_35(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 36u64 => { + let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_36(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 37u64 => { + let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_37(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 38u64 => { + let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_38(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 39u64 => { + let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_39(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 40u64 => { + let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_40(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 41u64 => { + let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_41(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 42u64 => { + let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_42(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 43u64 => { + let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_43(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 44u64 => { + let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_44(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 45u64 => { + let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_45(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 46u64 => { + let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_46(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 47u64 => { + let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_47(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 48u64 => { + let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_48(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 49u64 => { + let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_49(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 50u64 => { + let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_50(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 51u64 => { + let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_51(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 52u64 => { + let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_52(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 53u64 => { + let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_53(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 54u64 => { + let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_54(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 55u64 => { + let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_55(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 56u64 => { + let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_56(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 57u64 => { + let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_57(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 58u64 => { + let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_58(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 59u64 => { + let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_59(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 60u64 => { + let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_60(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 61u64 => { + let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_61(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 62u64 => { + let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_62(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 63u64 => { + let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_63(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 64u64 => { + let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_64(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 65u64 => { + let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_65(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 66u64 => { + let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_66(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 67u64 => { + let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_67(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 68u64 => { + let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_68(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 69u64 => { + let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_69(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 70u64 => { + let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_70(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 71u64 => { + let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_71(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 72u64 => { + let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_72(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 73u64 => { + let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_73(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 74u64 => { + let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_74(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 75u64 => { + let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_75(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 76u64 => { + let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_76(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 77u64 => { + let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_77(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 78u64 => { + let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_78(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 79u64 => { + let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_79(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 80u64 => { + let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_80(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 81u64 => { + let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_81(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 82u64 => { + let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_82(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 83u64 => { + let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_83(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 84u64 => { + let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_84(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 85u64 => { + let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_85(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 86u64 => { + let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_86(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 87u64 => { + let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_87(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 88u64 => { + let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_88(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 89u64 => { + let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_89(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 90u64 => { + let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_90(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 91u64 => { + let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_91(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 92u64 => { + let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_92(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 93u64 => { + let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_93(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 94u64 => { + let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_94(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 95u64 => { + let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_95(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 96u64 => { + let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_96(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 97u64 => { + let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_97(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 98u64 => { + let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_98(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 99u64 => { + let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_99(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 100u64 => { + let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_100(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 101u64 => { + let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_101(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 102u64 => { + let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_102(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 103u64 => { + let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_103(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 104u64 => { + let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_104(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 105u64 => { + let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_105(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 106u64 => { + let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_106(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 107u64 => { + let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_107(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 108u64 => { + let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_108(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 109u64 => { + let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_109(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 110u64 => { + let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_110(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 111u64 => { + let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_111(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 112u64 => { + let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_112(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 113u64 => { + let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_113(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 114u64 => { + let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_114(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 115u64 => { + let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_115(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 116u64 => { + let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_116(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 117u64 => { + let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_117(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 118u64 => { + let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_118(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 119u64 => { + let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_119(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 120u64 => { + let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_120(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 121u64 => { + let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_121(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 122u64 => { + let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_122(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 123u64 => { + let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_123(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 124u64 => { + let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_124(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 125u64 => { + let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_125(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 126u64 => { + let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_126(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 127u64 => { + let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_127(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 128u64 => { + let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_128(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 129u64 => { + let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_129(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 130u64 => { + let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_130(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 131u64 => { + let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_131(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 132u64 => { + let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_132(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 133u64 => { + let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_133(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 134u64 => { + let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_134(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 135u64 => { + let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_135(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 136u64 => { + let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_136(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 137u64 => { + let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_137(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 138u64 => { + let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_138(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 139u64 => { + let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_139(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 140u64 => { + let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_140(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 141u64 => { + let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_141(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 142u64 => { + let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_142(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 143u64 => { + let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_143(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 144u64 => { + let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_144(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 145u64 => { + let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_145(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 146u64 => { + let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_146(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 147u64 => { + let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_147(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 148u64 => { + let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_148(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 149u64 => { + let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_149(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 150u64 => { + let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_150(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 151u64 => { + let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_151(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 152u64 => { + let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_152(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 153u64 => { + let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_153(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 154u64 => { + let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_154(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 155u64 => { + let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_155(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 156u64 => { + let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_156(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 157u64 => { + let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_157(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 158u64 => { + let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_158(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 159u64 => { + let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_159(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 160u64 => { + let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_160(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 161u64 => { + let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_161(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 162u64 => { + let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_162(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 163u64 => { + let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_163(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 164u64 => { + let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_164(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 165u64 => { + let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_165(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 166u64 => { + let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_166(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 167u64 => { + let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_167(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 168u64 => { + let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_168(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 169u64 => { + let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_169(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 170u64 => { + let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_170(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 171u64 => { + let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_171(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 172u64 => { + let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_172(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 173u64 => { + let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_173(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 174u64 => { + let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_174(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 175u64 => { + let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_175(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 176u64 => { + let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_176(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 177u64 => { + let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_177(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 178u64 => { + let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_178(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 179u64 => { + let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_179(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 180u64 => { + let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_180(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 181u64 => { + let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_181(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 182u64 => { + let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_182(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 183u64 => { + let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_183(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 184u64 => { + let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_184(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 185u64 => { + let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_185(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 186u64 => { + let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_186(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 187u64 => { + let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_187(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 188u64 => { + let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_188(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 189u64 => { + let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_189(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 190u64 => { + let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_190(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 191u64 => { + let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_191(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 192u64 => { + let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_192(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 193u64 => { + let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_193(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 194u64 => { + let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_194(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 195u64 => { + let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_195(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 196u64 => { + let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_196(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 197u64 => { + let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_197(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 198u64 => { + let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_198(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 199u64 => { + let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_199(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 200u64 => { + let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_200(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 201u64 => { + let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_201(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 202u64 => { + let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_202(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 203u64 => { + let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_203(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 204u64 => { + let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_204(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 205u64 => { + let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_205(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 206u64 => { + let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_206(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 207u64 => { + let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_207(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 208u64 => { + let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_208(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 209u64 => { + let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_209(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 210u64 => { + let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_210(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 211u64 => { + let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_211(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 212u64 => { + let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_212(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 213u64 => { + let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_213(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 214u64 => { + let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_214(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 215u64 => { + let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_215(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 216u64 => { + let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_216(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 217u64 => { + let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_217(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 218u64 => { + let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_218(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 219u64 => { + let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_219(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 220u64 => { + let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_220(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 221u64 => { + let __inp: [G; IN_221] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_221(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 222u64 => { + let __inp: [G; IN_222] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_222(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 223u64 => { + let __inp: [G; IN_223] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_223(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 224u64 => { + let __inp: [G; IN_224] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_224(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 225u64 => { + let __inp: [G; IN_225] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_225(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 226u64 => { + let __inp: [G; IN_226] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_226(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 227u64 => { + let __inp: [G; IN_227] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_227(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 228u64 => { + let __inp: [G; IN_228] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_228(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 229u64 => { + let __inp: [G; IN_229] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_229(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 230u64 => { + let __inp: [G; IN_230] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_230(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 231u64 => { + let __inp: [G; IN_231] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_231(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 232u64 => { + let __inp: [G; IN_232] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_232(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 233u64 => { + let __inp: [G; IN_233] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_233(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 234u64 => { + let __inp: [G; IN_234] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_234(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 235u64 => { + let __inp: [G; IN_235] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_235(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 236u64 => { + let __inp: [G; IN_236] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_236(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 237u64 => { + let __inp: [G; IN_237] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_237(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 238u64 => { + let __inp: [G; IN_238] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_238(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 239u64 => { + let __inp: [G; IN_239] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_239(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 240u64 => { + let __inp: [G; IN_240] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_240(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 241u64 => { + let __inp: [G; IN_241] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_241(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 242u64 => { + let __inp: [G; IN_242] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_242(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 243u64 => { + let __inp: [G; IN_243] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_243(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 244u64 => { + let __inp: [G; IN_244] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_244(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 245u64 => { + let __inp: [G; IN_245] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_245(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 246u64 => { + let __inp: [G; IN_246] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_246(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 247u64 => { + let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_247(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 248u64 => { + let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_248(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 249u64 => { + let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_249(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 250u64 => { + let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_250(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 251u64 => { + let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_251(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 252u64 => { + let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_252(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 253u64 => { + let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_253(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 254u64 => { + let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_254(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 255u64 => { + let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_255(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 256u64 => { + let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_256(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 257u64 => { + let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_257(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 258u64 => { + let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_258(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 259u64 => { + let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_259(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 260u64 => { + let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_260(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 261u64 => { + let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_261(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 262u64 => { + let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_262(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 263u64 => { + let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_263(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 264u64 => { + let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_264(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 265u64 => { + let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_265(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 266u64 => { + let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_266(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 267u64 => { + let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_267(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 268u64 => { + let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_268(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 269u64 => { + let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_269(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 270u64 => { + let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_270(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 271u64 => { + let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_271(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 272u64 => { + let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_272(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 273u64 => { + let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_273(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 274u64 => { + let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_274(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 275u64 => { + let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_275(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 276u64 => { + let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_276(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 277u64 => { + let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_277(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 278u64 => { + let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_278(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 279u64 => { + let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_279(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 280u64 => { + let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_280(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 281u64 => { + let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_281(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 282u64 => { + let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_282(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 283u64 => { + let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_283(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 284u64 => { + let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_284(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 285u64 => { + let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_285(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 286u64 => { + let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_286(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 287u64 => { + let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_287(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 288u64 => { + let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_288(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 289u64 => { + let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_289(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 290u64 => { + let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_290(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 291u64 => { + let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_291(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 292u64 => { + let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_292(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 293u64 => { + let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_293(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 294u64 => { + let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_294(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 295u64 => { + let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_295(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 296u64 => { + let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_296(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 297u64 => { + let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_297(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 298u64 => { + let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_298(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 299u64 => { + let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_299(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 300u64 => { + let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_300(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 301u64 => { + let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_301(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 302u64 => { + let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_302(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 303u64 => { + let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_303(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 304u64 => { + let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_304(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 305u64 => { + let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_305(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 306u64 => { + let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_306(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 307u64 => { + let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_307(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 308u64 => { + let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_308(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 309u64 => { + let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_309(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 310u64 => { + let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_310(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 311u64 => { + let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_311(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 312u64 => { + let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_312(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 313u64 => { + let __inp: [G; IN_313] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_313(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 314u64 => { + let __inp: [G; IN_314] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_314(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 315u64 => { + let __inp: [G; IN_315] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_315(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 316u64 => { + let __inp: [G; IN_316] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_316(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 317u64 => { + let __inp: [G; IN_317] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_317(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 318u64 => { + let __inp: [G; IN_318] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_318(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 319u64 => { + let __inp: [G; IN_319] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_319(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 320u64 => { + let __inp: [G; IN_320] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_320(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 321u64 => { + let __inp: [G; IN_321] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_321(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 322u64 => { + let __inp: [G; IN_322] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_322(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 323u64 => { + let __inp: [G; IN_323] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_323(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 324u64 => { + let __inp: [G; IN_324] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_324(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 325u64 => { + let __inp: [G; IN_325] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_325(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 326u64 => { + let __inp: [G; IN_326] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_326(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 327u64 => { + let __inp: [G; IN_327] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_327(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 328u64 => { + let __inp: [G; IN_328] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_328(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 329u64 => { + let __inp: [G; IN_329] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_329(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 330u64 => { + let __inp: [G; IN_330] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_330(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 331u64 => { + let __inp: [G; IN_331] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_331(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 332u64 => { + let __inp: [G; IN_332] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_332(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 333u64 => { + let __inp: [G; IN_333] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_333(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 334u64 => { + let __inp: [G; IN_334] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_334(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 335u64 => { + let __inp: [G; IN_335] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_335(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 336u64 => { + let __inp: [G; IN_336] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_336(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 337u64 => { + let __inp: [G; IN_337] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_337(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 338u64 => { + let __inp: [G; IN_338] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_338(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 339u64 => { + let __inp: [G; IN_339] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_339(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 340u64 => { + let __inp: [G; IN_340] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_340(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 341u64 => { + let __inp: [G; IN_341] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_341(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 342u64 => { + let __inp: [G; IN_342] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_342(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 343u64 => { + let __inp: [G; IN_343] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_343(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 344u64 => { + let __inp: [G; IN_344] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_344(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 345u64 => { + let __inp: [G; IN_345] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_345(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 346u64 => { + let __inp: [G; IN_346] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_346(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 347u64 => { + let __inp: [G; IN_347] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_347(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 348u64 => { + let __inp: [G; IN_348] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_348(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 349u64 => { + let __inp: [G; IN_349] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_349(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 350u64 => { + let __inp: [G; IN_350] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_350(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 351u64 => { + let __inp: [G; IN_351] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_351(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 352u64 => { + let __inp: [G; IN_352] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_352(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 353u64 => { + let __inp: [G; IN_353] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_353(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 354u64 => { + let __inp: [G; IN_354] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_354(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 355u64 => { + let __inp: [G; IN_355] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_355(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 356u64 => { + let __inp: [G; IN_356] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_356(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 357u64 => { + let __inp: [G; IN_357] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_357(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 358u64 => { + let __inp: [G; IN_358] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_358(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 359u64 => { + let __inp: [G; IN_359] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_359(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 360u64 => { + let __inp: [G; IN_360] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_360(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 361u64 => { + let __inp: [G; IN_361] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_361(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 362u64 => { + let __inp: [G; IN_362] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_362(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 363u64 => { + let __inp: [G; IN_363] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_363(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 364u64 => { + let __inp: [G; IN_364] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_364(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 365u64 => { + let __inp: [G; IN_365] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_365(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 366u64 => { + let __inp: [G; IN_366] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_366(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 367u64 => { + let __inp: [G; IN_367] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_367(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 368u64 => { + let __inp: [G; IN_368] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_368(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 369u64 => { + let __inp: [G; IN_369] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_369(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 370u64 => { + let __inp: [G; IN_370] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_370(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 371u64 => { + let __inp: [G; IN_371] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_371(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 372u64 => { + let __inp: [G; IN_372] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_372(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 373u64 => { + let __inp: [G; IN_373] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_373(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 374u64 => { + let __inp: [G; IN_374] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_374(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 375u64 => { + let __inp: [G; IN_375] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_375(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 376u64 => { + let __inp: [G; IN_376] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_376(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 377u64 => { + let __inp: [G; IN_377] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_377(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 378u64 => { + let __inp: [G; IN_378] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_378(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 379u64 => { + let __inp: [G; IN_379] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_379(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 380u64 => { + let __inp: [G; IN_380] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_380(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 381u64 => { + let __inp: [G; IN_381] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_381(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 382u64 => { + let __inp: [G; IN_382] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_382(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 383u64 => { + let __inp: [G; IN_383] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_383(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 384u64 => { + let __inp: [G; IN_384] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_384(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 385u64 => { + let __inp: [G; IN_385] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_385(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 386u64 => { + let __inp: [G; IN_386] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_386(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 387u64 => { + let __inp: [G; IN_387] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_387(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 388u64 => { + let __inp: [G; IN_388] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_388(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 389u64 => { + let __inp: [G; IN_389] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_389(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 390u64 => { + let __inp: [G; IN_390] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_390(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 391u64 => { + let __inp: [G; IN_391] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_391(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 392u64 => { + let __inp: [G; IN_392] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_392(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 393u64 => { + let __inp: [G; IN_393] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_393(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 394u64 => { + let __inp: [G; IN_394] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_394(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 395u64 => { + let __inp: [G; IN_395] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_395(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 396u64 => { + let __inp: [G; IN_396] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_396(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 397u64 => { + let __inp: [G; IN_397] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_397(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 398u64 => { + let __inp: [G; IN_398] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_398(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 399u64 => { + let __inp: [G; IN_399] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_399(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 400u64 => { + let __inp: [G; IN_400] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_400(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 401u64 => { + let __inp: [G; IN_401] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_401(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 402u64 => { + let __inp: [G; IN_402] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_402(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 403u64 => { + let __inp: [G; IN_403] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_403(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 404u64 => { + let __inp: [G; IN_404] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_404(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 405u64 => { + let __inp: [G; IN_405] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_405(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 406u64 => { + let __inp: [G; IN_406] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_406(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 407u64 => { + let __inp: [G; IN_407] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_407(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 408u64 => { + let __inp: [G; IN_408] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_408(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 409u64 => { + let __inp: [G; IN_409] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_409(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 410u64 => { + let __inp: [G; IN_410] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_410(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 411u64 => { + let __inp: [G; IN_411] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_411(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 412u64 => { + let __inp: [G; IN_412] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_412(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 413u64 => { + let __inp: [G; IN_413] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_413(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 414u64 => { + let __inp: [G; IN_414] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_414(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 415u64 => { + let __inp: [G; IN_415] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_415(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 416u64 => { + let __inp: [G; IN_416] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_416(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 417u64 => { + let __inp: [G; IN_417] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_417(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 418u64 => { + let __inp: [G; IN_418] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_418(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 419u64 => { + let __inp: [G; IN_419] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_419(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 420u64 => { + let __inp: [G; IN_420] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_420(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 421u64 => { + let __inp: [G; IN_421] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_421(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 422u64 => { + let __inp: [G; IN_422] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_422(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 423u64 => { + let __inp: [G; IN_423] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_423(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 424u64 => { + let __inp: [G; IN_424] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_424(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 425u64 => { + let __inp: [G; IN_425] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_425(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 426u64 => { + let __inp: [G; IN_426] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_426(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 427u64 => { + let __inp: [G; IN_427] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_427(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 428u64 => { + let __inp: [G; IN_428] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_428(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 429u64 => { + let __inp: [G; IN_429] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_429(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 430u64 => { + let __inp: [G; IN_430] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_430(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 431u64 => { + let __inp: [G; IN_431] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_431(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 432u64 => { + let __inp: [G; IN_432] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_432(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 433u64 => { + let __inp: [G; IN_433] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_433(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 434u64 => { + let __inp: [G; IN_434] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_434(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 435u64 => { + let __inp: [G; IN_435] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_435(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 436u64 => { + let __inp: [G; IN_436] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_436(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 437u64 => { + let __inp: [G; IN_437] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_437(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 438u64 => { + let __inp: [G; IN_438] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_438(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 439u64 => { + let __inp: [G; IN_439] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_439(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 440u64 => { + let __inp: [G; IN_440] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_440(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 441u64 => { + let __inp: [G; IN_441] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_441(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 442u64 => { + let __inp: [G; IN_442] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_442(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 443u64 => { + let __inp: [G; IN_443] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_443(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 444u64 => { + let __inp: [G; IN_444] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_444(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 445u64 => { + let __inp: [G; IN_445] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_445(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 446u64 => { + let __inp: [G; IN_446] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_446(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 447u64 => { + let __inp: [G; IN_447] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_447(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 448u64 => { + let __inp: [G; IN_448] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_448(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 449u64 => { + let __inp: [G; IN_449] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_449(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 450u64 => { + let __inp: [G; IN_450] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_450(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 451u64 => { + let __inp: [G; IN_451] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_451(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 452u64 => { + let __inp: [G; IN_452] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_452(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 453u64 => { + let __inp: [G; IN_453] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_453(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 454u64 => { + let __inp: [G; IN_454] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_454(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 455u64 => { + let __inp: [G; IN_455] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_455(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 456u64 => { + let __inp: [G; IN_456] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_456(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 457u64 => { + let __inp: [G; IN_457] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_457(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 458u64 => { + let __inp: [G; IN_458] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_458(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 459u64 => { + let __inp: [G; IN_459] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_459(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 460u64 => { + let __inp: [G; IN_460] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_460(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 461u64 => { + let __inp: [G; IN_461] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_461(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 462u64 => { + let __inp: [G; IN_462] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_462(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 463u64 => { + let __inp: [G; IN_463] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_463(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 464u64 => { + let __inp: [G; IN_464] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_464(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 465u64 => { + let __inp: [G; IN_465] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_465(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 466u64 => { + let __inp: [G; IN_466] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_466(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 467u64 => { + let __inp: [G; IN_467] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_467(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 468u64 => { + let __inp: [G; IN_468] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_468(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 469u64 => { + let __inp: [G; IN_469] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_469(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 470u64 => { + let __inp: [G; IN_470] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_470(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 471u64 => { + let __inp: [G; IN_471] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_471(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 472u64 => { + let __inp: [G; IN_472] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_472(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 473u64 => { + let __inp: [G; IN_473] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_473(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 474u64 => { + let __inp: [G; IN_474] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_474(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 475u64 => { + let __inp: [G; IN_475] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_475(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 476u64 => { + let __inp: [G; IN_476] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_476(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 477u64 => { + let __inp: [G; IN_477] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_477(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 478u64 => { + let __inp: [G; IN_478] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_478(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 479u64 => { + let __inp: [G; IN_479] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_479(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 480u64 => { + let __inp: [G; IN_480] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_480(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 481u64 => { + let __inp: [G; IN_481] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_481(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 482u64 => { + let __inp: [G; IN_482] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_482(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 483u64 => { + let __inp: [G; IN_483] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_483(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 484u64 => { + let __inp: [G; IN_484] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_484(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 485u64 => { + let __inp: [G; IN_485] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_485(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 486u64 => { + let __inp: [G; IN_486] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_486(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 487u64 => { + let __inp: [G; IN_487] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_487(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 488u64 => { + let __inp: [G; IN_488] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_488(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 489u64 => { + let __inp: [G; IN_489] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_489(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 490u64 => { + let __inp: [G; IN_490] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_490(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 491u64 => { + let __inp: [G; IN_491] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_491(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 492u64 => { + let __inp: [G; IN_492] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_492(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 493u64 => { + let __inp: [G; IN_493] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_493(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 494u64 => { + let __inp: [G; IN_494] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_494(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 495u64 => { + let __inp: [G; IN_495] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_495(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 496u64 => { + let __inp: [G; IN_496] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_496(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 497u64 => { + let __inp: [G; IN_497] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_497(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 498u64 => { + let __inp: [G; IN_498] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_498(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 499u64 => { + let __inp: [G; IN_499] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_499(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 500u64 => { + let __inp: [G; IN_500] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_500(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 501u64 => { + let __inp: [G; IN_501] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_501(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 502u64 => { + let __inp: [G; IN_502] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_502(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 503u64 => { + let __inp: [G; IN_503] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_503(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 504u64 => { + let __inp: [G; IN_504] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_504(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 505u64 => { + let __inp: [G; IN_505] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_505(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 506u64 => { + let __inp: [G; IN_506] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_506(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 507u64 => { + let __inp: [G; IN_507] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_507(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 508u64 => { + let __inp: [G; IN_508] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_508(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 509u64 => { + let __inp: [G; IN_509] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_509(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 510u64 => { + let __inp: [G; IN_510] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_510(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 511u64 => { + let __inp: [G; IN_511] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_511(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 512u64 => { + let __inp: [G; IN_512] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_512(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 513u64 => { + let __inp: [G; IN_513] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_513(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 514u64 => { + let __inp: [G; IN_514] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_514(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 515u64 => { + let __inp: [G; IN_515] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_515(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 516u64 => { + let __inp: [G; IN_516] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_516(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 517u64 => { + let __inp: [G; IN_517] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_517(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 518u64 => { + let __inp: [G; IN_518] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_518(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 519u64 => { + let __inp: [G; IN_519] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_519(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 520u64 => { + let __inp: [G; IN_520] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_520(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 521u64 => { + let __inp: [G; IN_521] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_521(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 522u64 => { + let __inp: [G; IN_522] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_522(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 523u64 => { + let __inp: [G; IN_523] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_523(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 524u64 => { + let __inp: [G; IN_524] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_524(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 525u64 => { + let __inp: [G; IN_525] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_525(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 526u64 => { + let __inp: [G; IN_526] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_526(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 527u64 => { + let __inp: [G; IN_527] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_527(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 528u64 => { + let __inp: [G; IN_528] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_528(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 529u64 => { + let __inp: [G; IN_529] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_529(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 530u64 => { + let __inp: [G; IN_530] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_530(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 531u64 => { + let __inp: [G; IN_531] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_531(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 532u64 => { + let __inp: [G; IN_532] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_532(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 533u64 => { + let __inp: [G; IN_533] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_533(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 534u64 => { + let __inp: [G; IN_534] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_534(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 535u64 => { + let __inp: [G; IN_535] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_535(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 536u64 => { + let __inp: [G; IN_536] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_536(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 537u64 => { + let __inp: [G; IN_537] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_537(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 538u64 => { + let __inp: [G; IN_538] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_538(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 539u64 => { + let __inp: [G; IN_539] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_539(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 540u64 => { + let __inp: [G; IN_540] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_540(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 541u64 => { + let __inp: [G; IN_541] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_541(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 542u64 => { + let __inp: [G; IN_542] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_542(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 543u64 => { + let __inp: [G; IN_543] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_543(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 544u64 => { + let __inp: [G; IN_544] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_544(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 545u64 => { + let __inp: [G; IN_545] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_545(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 546u64 => { + let __inp: [G; IN_546] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_546(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 547u64 => { + let __inp: [G; IN_547] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_547(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 548u64 => { + let __inp: [G; IN_548] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_548(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 549u64 => { + let __inp: [G; IN_549] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_549(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 550u64 => { + let __inp: [G; IN_550] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_550(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 551u64 => { + let __inp: [G; IN_551] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_551(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 552u64 => { + let __inp: [G; IN_552] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_552(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 553u64 => { + let __inp: [G; IN_553] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_553(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 554u64 => { + let __inp: [G; IN_554] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_554(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 555u64 => { + let __inp: [G; IN_555] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_555(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 556u64 => { + let __inp: [G; IN_556] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_556(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 557u64 => { + let __inp: [G; IN_557] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_557(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 558u64 => { + let __inp: [G; IN_558] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_558(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 559u64 => { + let __inp: [G; IN_559] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_559(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 560u64 => { + let __inp: [G; IN_560] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_560(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 561u64 => { + let __inp: [G; IN_561] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_561(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 562u64 => { + let __inp: [G; IN_562] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_562(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 563u64 => { + let __inp: [G; IN_563] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_563(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 564u64 => { + let __inp: [G; IN_564] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_564(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 565u64 => { + let __inp: [G; IN_565] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_565(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 566u64 => { + let __inp: [G; IN_566] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_566(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 567u64 => { + let __inp: [G; IN_567] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_567(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 568u64 => { + let __inp: [G; IN_568] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_568(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 569u64 => { + let __inp: [G; IN_569] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_569(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 570u64 => { + let __inp: [G; IN_570] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_570(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 571u64 => { + let __inp: [G; IN_571] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_571(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 572u64 => { + let __inp: [G; IN_572] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_572(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 573u64 => { + let __inp: [G; IN_573] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_573(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 574u64 => { + let __inp: [G; IN_574] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_574(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 575u64 => { + let __inp: [G; IN_575] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_575(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 576u64 => { + let __inp: [G; IN_576] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_576(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 577u64 => { + let __inp: [G; IN_577] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_577(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 578u64 => { + let __inp: [G; IN_578] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_578(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 579u64 => { + let __inp: [G; IN_579] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_579(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 580u64 => { + let __inp: [G; IN_580] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_580(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 581u64 => { + let __inp: [G; IN_581] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_581(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 582u64 => { + let __inp: [G; IN_582] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_582(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 583u64 => { + let __inp: [G; IN_583] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_583(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 584u64 => { + let __inp: [G; IN_584] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_584(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 585u64 => { + let __inp: [G; IN_585] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_585(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 586u64 => { + let __inp: [G; IN_586] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_586(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 587u64 => { + let __inp: [G; IN_587] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_587(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 588u64 => { + let __inp: [G; IN_588] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_588(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 589u64 => { + let __inp: [G; IN_589] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_589(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 590u64 => { + let __inp: [G; IN_590] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_590(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 591u64 => { + let __inp: [G; IN_591] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_591(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 592u64 => { + let __inp: [G; IN_592] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_592(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 593u64 => { + let __inp: [G; IN_593] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_593(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 594u64 => { + let __inp: [G; IN_594] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_594(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 595u64 => { + let __inp: [G; IN_595] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_595(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 596u64 => { + let __inp: [G; IN_596] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_596(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 597u64 => { + let __inp: [G; IN_597] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_597(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 598u64 => { + let __inp: [G; IN_598] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_598(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 599u64 => { + let __inp: [G; IN_599] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_599(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 600u64 => { + let __inp: [G; IN_600] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_600(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 601u64 => { + let __inp: [G; IN_601] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_601(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 602u64 => { + let __inp: [G; IN_602] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_602(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 603u64 => { + let __inp: [G; IN_603] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_603(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 604u64 => { + let __inp: [G; IN_604] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_604(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 605u64 => { + let __inp: [G; IN_605] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_605(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 606u64 => { + let __inp: [G; IN_606] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_606(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 607u64 => { + let __inp: [G; IN_607] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_607(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 608u64 => { + let __inp: [G; IN_608] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_608(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 609u64 => { + let __inp: [G; IN_609] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_609(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 610u64 => { + let __inp: [G; IN_610] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_610(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 611u64 => { + let __inp: [G; IN_611] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_611(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 612u64 => { + let __inp: [G; IN_612] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_612(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 613u64 => { + let __inp: [G; IN_613] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_613(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 614u64 => { + let __inp: [G; IN_614] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_614(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 615u64 => { + let __inp: [G; IN_615] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_615(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 616u64 => { + let __inp: [G; IN_616] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_616(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 617u64 => { + let __inp: [G; IN_617] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_617(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 618u64 => { + let __inp: [G; IN_618] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_618(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 619u64 => { + let __inp: [G; IN_619] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_619(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 620u64 => { + let __inp: [G; IN_620] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_620(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 621u64 => { + let __inp: [G; IN_621] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_621(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 622u64 => { + let __inp: [G; IN_622] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_622(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 623u64 => { + let __inp: [G; IN_623] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_623(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 624u64 => { + let __inp: [G; IN_624] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_624(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 625u64 => { + let __inp: [G; IN_625] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_625(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 626u64 => { + let __inp: [G; IN_626] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_626(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 627u64 => { + let __inp: [G; IN_627] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_627(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 628u64 => { + let __inp: [G; IN_628] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_628(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 629u64 => { + let __inp: [G; IN_629] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_629(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 630u64 => { + let __inp: [G; IN_630] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_630(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 631u64 => { + let __inp: [G; IN_631] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_631(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 632u64 => { + let __inp: [G; IN_632] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_632(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 633u64 => { + let __inp: [G; IN_633] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_633(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 634u64 => { + let __inp: [G; IN_634] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_634(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 635u64 => { + let __inp: [G; IN_635] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_635(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 636u64 => { + let __inp: [G; IN_636] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_636(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 637u64 => { + let __inp: [G; IN_637] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_637(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 638u64 => { + let __inp: [G; IN_638] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_638(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 639u64 => { + let __inp: [G; IN_639] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_639(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 640u64 => { + let __inp: [G; IN_640] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_640(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 641u64 => { + let __inp: [G; IN_641] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_641(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 642u64 => { + let __inp: [G; IN_642] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_642(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 643u64 => { + let __inp: [G; IN_643] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_643(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 644u64 => { + let __inp: [G; IN_644] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_644(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 645u64 => { + let __inp: [G; IN_645] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_645(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 646u64 => { + let __inp: [G; IN_646] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_646(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 647u64 => { + let __inp: [G; IN_647] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_647(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 648u64 => { + let __inp: [G; IN_648] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_648(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 649u64 => { + let __inp: [G; IN_649] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_649(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 650u64 => { + let __inp: [G; IN_650] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_650(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 651u64 => { + let __inp: [G; IN_651] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_651(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 652u64 => { + let __inp: [G; IN_652] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_652(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 653u64 => { + let __inp: [G; IN_653] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_653(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 654u64 => { + let __inp: [G; IN_654] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_654(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 655u64 => { + let __inp: [G; IN_655] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_655(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 656u64 => { + let __inp: [G; IN_656] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_656(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 657u64 => { + let __inp: [G; IN_657] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_657(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 658u64 => { + let __inp: [G; IN_658] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_658(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 659u64 => { + let __inp: [G; IN_659] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_659(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 660u64 => { + let __inp: [G; IN_660] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_660(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 661u64 => { + let __inp: [G; IN_661] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_661(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 662u64 => { + let __inp: [G; IN_662] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_662(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 663u64 => { + let __inp: [G; IN_663] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_663(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 664u64 => { + let __inp: [G; IN_664] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_664(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 665u64 => { + let __inp: [G; IN_665] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_665(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 666u64 => { + let __inp: [G; IN_666] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_666(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 667u64 => { + let __inp: [G; IN_667] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_667(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 668u64 => { + let __inp: [G; IN_668] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_668(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 669u64 => { + let __inp: [G; IN_669] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_669(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 670u64 => { + let __inp: [G; IN_670] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_670(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 671u64 => { + let __inp: [G; IN_671] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_671(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 672u64 => { + let __inp: [G; IN_672] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_672(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 673u64 => { + let __inp: [G; IN_673] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_673(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 674u64 => { + let __inp: [G; IN_674] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_674(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 675u64 => { + let __inp: [G; IN_675] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_675(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 676u64 => { + let __inp: [G; IN_676] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_676(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 677u64 => { + let __inp: [G; IN_677] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_677(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 678u64 => { + let __inp: [G; IN_678] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_678(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 679u64 => { + let __inp: [G; IN_679] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_679(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 680u64 => { + let __inp: [G; IN_680] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_680(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 681u64 => { + let __inp: [G; IN_681] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_681(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 682u64 => { + let __inp: [G; IN_682] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_682(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 683u64 => { + let __inp: [G; IN_683] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_683(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 684u64 => { + let __inp: [G; IN_684] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_684(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 685u64 => { + let __inp: [G; IN_685] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_685(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 686u64 => { + let __inp: [G; IN_686] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_686(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 687u64 => { + let __inp: [G; IN_687] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_687(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 688u64 => { + let __inp: [G; IN_688] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_688(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 689u64 => { + let __inp: [G; IN_689] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_689(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 690u64 => { + let __inp: [G; IN_690] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_690(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 691u64 => { + let __inp: [G; IN_691] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_691(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 692u64 => { + let __inp: [G; IN_692] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_692(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 693u64 => { + let __inp: [G; IN_693] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_693(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 694u64 => { + let __inp: [G; IN_694] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_694(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 695u64 => { + let __inp: [G; IN_695] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_695(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 696u64 => { + let __inp: [G; IN_696] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_696(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 697u64 => { + let __inp: [G; IN_697] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_697(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 698u64 => { + let __inp: [G; IN_698] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_698(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 699u64 => { + let __inp: [G; IN_699] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_699(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 700u64 => { + let __inp: [G; IN_700] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_700(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 701u64 => { + let __inp: [G; IN_701] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_701(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 702u64 => { + let __inp: [G; IN_702] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_702(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 703u64 => { + let __inp: [G; IN_703] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_703(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 704u64 => { + let __inp: [G; IN_704] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_704(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 705u64 => { + let __inp: [G; IN_705] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_705(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 706u64 => { + let __inp: [G; IN_706] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_706(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 707u64 => { + let __inp: [G; IN_707] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_707(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 708u64 => { + let __inp: [G; IN_708] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_708(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 709u64 => { + let __inp: [G; IN_709] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_709(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 710u64 => { + let __inp: [G; IN_710] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_710(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 711u64 => { + let __inp: [G; IN_711] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_711(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 712u64 => { + let __inp: [G; IN_712] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_712(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 713u64 => { + let __inp: [G; IN_713] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_713(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 714u64 => { + let __inp: [G; IN_714] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_714(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 715u64 => { + let __inp: [G; IN_715] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_715(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 716u64 => { + let __inp: [G; IN_716] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_716(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 717u64 => { + let __inp: [G; IN_717] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_717(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 718u64 => { + let __inp: [G; IN_718] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_718(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 719u64 => { + let __inp: [G; IN_719] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_719(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 720u64 => { + let __inp: [G; IN_720] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_720(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 721u64 => { + let __inp: [G; IN_721] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_721(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 722u64 => { + let __inp: [G; IN_722] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_722(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 723u64 => { + let __inp: [G; IN_723] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_723(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 724u64 => { + let __inp: [G; IN_724] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_724(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 725u64 => { + let __inp: [G; IN_725] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_725(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 726u64 => { + let __inp: [G; IN_726] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_726(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 727u64 => { + let __inp: [G; IN_727] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_727(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 728u64 => { + let __inp: [G; IN_728] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_728(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 729u64 => { + let __inp: [G; IN_729] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_729(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 730u64 => { + let __inp: [G; IN_730] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_730(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 731u64 => { + let __inp: [G; IN_731] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_731(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 732u64 => { + let __inp: [G; IN_732] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_732(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 733u64 => { + let __inp: [G; IN_733] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_733(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 734u64 => { + let __inp: [G; IN_734] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_734(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 735u64 => { + let __inp: [G; IN_735] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_735(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 736u64 => { + let __inp: [G; IN_736] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_736(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 737u64 => { + let __inp: [G; IN_737] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_737(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 738u64 => { + let __inp: [G; IN_738] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_738(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 739u64 => { + let __inp: [G; IN_739] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_739(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 740u64 => { + let __inp: [G; IN_740] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_740(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 741u64 => { + let __inp: [G; IN_741] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_741(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 742u64 => { + let __inp: [G; IN_742] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_742(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + _ => { + return Err(ExecError::InvalidFunIdx(fun_idx)); + }, + } +} diff --git a/crates/ix/src/aiur_ixvm_runner.rs b/crates/ix/src/aiur_ixvm_runner.rs new file mode 100644 index 00000000..aacc2d17 --- /dev/null +++ b/crates/ix/src/aiur_ixvm_runner.rs @@ -0,0 +1,39 @@ +//! IxVM-native execute path. +//! +//! Parallel to `aiur::execute::Toplevel::execute`, but routes the +//! Aiur fn invocation through the codegen'd Rust kernel +//! (`crate::aiur_ixvm::execute_generated`) instead of the interpreter. +//! +//! Same `QueryRecord` shape, same multiplicity rules, same memory and +//! IO side effects — so the trace produced here is byte-for-byte +//! identical to the interpreter's (modulo the `execute_generated` +//! codegen's correctness, which is the standing parity invariant). +//! +//! Caller still needs a `Toplevel` to size the `QueryRecord` correctly +//! (one `QueryMap` per function, one per `memory_sizes` entry). The +//! `Toplevel`'s bytecode is NOT walked at execution time; only its +//! shape is consulted. + +use aiur::G; +use aiur::bytecode::{FunIdx, Toplevel}; +use aiur::execute::{ExecError, IOBuffer, QueryRecord}; +use crate::aiur_ixvm::execute_generated; + +/// Mirror of `Toplevel::execute` (same return shape, same +/// `entry`-flag gate), but routes execution through the codegen'd +/// Rust kernel. Deep recursion is handled via per-fn +/// `stacker::maybe_grow` checks in the generated code — no +/// pre-reserved giant stack on this thread, no scope dance. +pub fn execute_ixvm( + toplevel: &Toplevel, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, +) -> Result<(QueryRecord, Vec), ExecError> { + if !toplevel.functions[fun_idx].entry { + return Err(ExecError::NotEntryFunction(fun_idx)); + } + let mut record = QueryRecord::new(toplevel); + let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; + Ok((record, output)) +} diff --git a/crates/ix/src/lib.rs b/crates/ix/src/lib.rs new file mode 100644 index 00000000..573878f4 --- /dev/null +++ b/crates/ix/src/lib.rs @@ -0,0 +1,6 @@ +//! IxVM-specific Rust glue: codegen'd kernel, native runner, witness +//! builder. Bridges the `aiur` proving framework with `ixon` / +//! `ix-common` content-addressed env types. + +pub mod aiur_ixvm; +pub mod aiur_ixvm_runner; From 32fcbdaef3e86c6bad870005b922560b4b11fb82 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 06:57:56 -0700 Subject: [PATCH 06/11] Move shard witness construction to Rust + parallelise MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replaces `IxVM.ClaimHarness.buildShardCheckEnvWitness` (Lean side, ~92% of shard wall time on heavy partitions) with a Rust port that builds the `aiur::execute::IOBuffer` directly, without per-byte boxing into Lean `Aiur.G` values. The two hot phases run on rayon: * Closure walk: each owned addr's transitive `Constant.refs` + projection-block traversal runs on its own thread; results are deduped through a `dashmap::DashSet`. * Byte-to-G conversion: per-const `(key, data)` tuples are built in parallel chunks of 256; final IOBuffer assembly (channel arena append + key→`IOKeyInfo` map insert) runs serially because the arena index is monotonic. * `src/ix/aiur_ixvm_witness.rs` (new): `build_shard_check_env_witness` produces `(claim, claim_digest_input, io_buffer)` ready to feed to `execute_ixvm`. Mirrors the 6-channel layout documented in `Ix/IxVM/ClaimHarness.lean` (claim / asm tree / const bytes / Defn hint / blob discriminator / blob raw bytes). * `src/ffi/aiur/protocol.rs`: new FFI `rs_aiur_toplevel_shard_check_ixvm` bundles witness build + `execute_ixvm` into one cross-language trip. Returns the same `(output, ioBuffer, queryCounts)` shape as `rs_aiur_toplevel_execute_ixvm`, so the Lean shim stays drop-in compatible. * `Ix/Aiur/Semantics/BytecodeFfi.lean`: `Bytecode.Toplevel.shardCheckIxVM` wraps the FFI. * `Ix/Cli/CheckCmd.lean`: shard-mode `ix check` (`--ixe + --ixes`) now dispatches through `runShardOwnedNative` → `shardCheckIxVM`, bypassing the Lean witness builder. Single- shard and whole-partition paths share the fast route; the legacy `runShardCheckManifest` / `runShardCheckAll` callbacks stay live for `--interp` only. Shard 26 of the 64-way `init.ixes` partition, on the same host: | Variant | total | speedup | | --- | --: | --: | | Lean witness + bytecode-interp (baseline)| 1029 s | 1.0× | | Lean witness + codegen kernel | 1015 s | 1.01× | | Rust witness (serial) + codegen | 101 s | 9.95× | | Rust witness (parallel) + codegen | 80 s | 12.9× | The serial Rust witness collapses the 935 s of Lean per-byte boxing into ~23 s; rayon hides that 23 s under the codegen-kernel execute (~78 s) so witness build effectively becomes free at the shard level. FFT cost matches the bytecode interpreter exactly (107_006_963_281), so the QueryRecord layout is bit-identical across all four variants. * Closure walk uses single-source BFS with the global visited set shared via `DashSet::contains` checks before pushing to the per-thread stack — avoids redundant work without a per-owned union step. * Per-channel ordering: each chunk's partial `ChannelEntries` feeds the serial fold in iteration order, so channel arena contents match the Lean side's exactly. Test still relies on trace-hash parity from the earlier codegen commit, which exercised the same path through the bytecode interpreter and the codegen kernel. * Coverage check is currently skipped on the IxVM-native whole-partition path (`runShardManifestAllNative`); legacy `runShardCheckAll` still does it for `--interp`. Re-enable separately if needed. --- Ix/Aiur/Semantics/BytecodeFfi.lean | 27 +++ Ix/Cli/CheckCmd.lean | 84 ++++++++- crates/ffi/src/aiur/protocol.rs | 103 +++++++++++ crates/ix/src/aiur_ixvm_witness.rs | 273 +++++++++++++++++++++++++++++ crates/ix/src/lib.rs | 1 + 5 files changed, 485 insertions(+), 3 deletions(-) create mode 100644 crates/ix/src/aiur_ixvm_witness.rs diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 2c7d2e9f..3f3b191b 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -126,6 +126,33 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) +@[extern "rs_aiur_toplevel_shard_check_ixvm"] +private opaque shardCheckIxVM' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + + +/-- IxVM-native shard check: builds the witness in Rust (no + per-byte boxing into Lean values), then dispatches through + `execute_ixvm`. Replaces `buildShardCheckEnvWitness` + `executeIxVM` + with a single FFI call. + + `ixePath` is a UTF-8 path to a memory-mappable `.ixe` env; + Rust loads it lazily. `ownedBlob` is a flat ByteArray of 32-byte + address blocks (one per owned const). -/ +def shardCheckIxVM (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (ownedBlob : ByteArray) + : Except String (Array G × IOBuffer × Array QueryCount) := + match shardCheckIxVM' toplevel funIdx ixePath ownedBlob with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + end Bytecode.Toplevel end Aiur diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 497c03b2..691445c8 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -340,6 +340,33 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) | .error e => IO.eprintln s!"shard witness build failed: {e}"; return 1 | .ok (claim, witness) => runOne claim witness s!"shard {shardK}" +/-- IxVM-native fast path: skip Lean-side `buildShardCheckEnvWitness` + and dispatch through the new `shardCheckIxVM` FFI which builds + the witness in Rust directly. `--ixe` path is required (the + Rust side memory-maps it). -/ +def runShardOwnedNative (ixePath : String) (compiled : Aiur.CompiledToplevel) + (printStats : Bool) (statsOut : Option String) + (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do + let owned := ownedConstsForBlocks ixonEnv blocks + IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ + {owned.size}/{ixonEnv.consts.size} owned consts" + let label := s!"shard {shardK}" + IO.println s!"Typechecking {label}" + (← IO.getStdout).flush + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let ixePathBytes := ixePath.toUTF8 + -- Flat 32-byte address ByteArray. + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + match compiled.bytecode.shardCheckIxVM funIdx ixePathBytes blob with + | .error e => + IO.eprintln s!"{label}: IxVM-native shard check error: {e}" + return 1 + | .ok (_output, _ioBuffer, queryCounts) => + if printStats then emitStats compiled queryCounts statsOut + pure 0 + /-- Manifest-driven check/prove of one shard `shardK` of the partition. -/ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) : IO UInt32 := do @@ -349,6 +376,39 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 | some blocks => runShardOwned ixonEnv blocks shardK runOne +/-- IxVM-native shard check: skip Lean's `buildShardCheckEnvWitness` + by dispatching the witness build to Rust via `shardCheckIxVM`. -/ +def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) + (compiled : Aiur.CompiledToplevel) (printStats : Bool) + (statsOut : Option String) : IO UInt32 := do + match (← loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => match shards[shardK]? with + | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 + | some blocks => + runShardOwnedNative ixePath compiled printStats statsOut ixonEnv blocks shardK + +/-- IxVM-native check over EVERY shard. Caller-side: this skips the + coverage check; trust the user (or run a separate `--ixes`-only + coverage probe first). -/ +def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) + (compiled : Aiur.CompiledToplevel) (printStats : Bool) + (statsOut : Option String) : IO UInt32 := do + match (← loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let maxJobs := max 1 (jobs?.getD shards.size) + let mut rc : UInt32 := 0 + for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do + let tasks ← chunk.mapM fun (blocks, k) => + IO.asTask (prio := .dedicated) + (runShardOwnedNative ixePath compiled printStats statsOut ixonEnv blocks k) + for t in tasks do + match t.get with + | .ok r => if r != 0 then rc := 1 + | .error e => IO.eprintln s!"shard check task failed: {e}"; rc := 1 + pure rc + /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 if any shard fails, else 0. -/ @@ -457,10 +517,28 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do pure (runCompiled compiled printStats statsOut) match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => - return (← runShardCheckManifest manifest ixe k (fun _c w l => runOne w l)) + -- IxVM-native shard check: witness built in Rust (Lean's + -- `buildShardCheckEnvWitness` dominates per-shard wall time, + -- ~92%; native build avoids per-byte boxing into `Aiur.G`). + -- Falls back to the legacy path when `--interp` is set, since + -- the Lean interpreter consumes a `ClaimWitness` directly. + if interp then + return (← runShardCheckManifest manifest ixe k (fun _c w l => runOne w l)) + else do + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut) | some ixe, some manifest, none => - return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) - (fun _c w l => runOne w l)) + if interp then + return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) + (fun _c w l => runOne w l)) + else do + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + return (← runShardManifestAllNative manifest ixe + ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut) | _, _, _ => forEachClaim ixePath claimHex names keepGoing "check" (fun _ w l => runOne w l) diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index eb481a8f..99a5080f 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -267,6 +267,109 @@ extern "C" fn rs_aiur_system_prove( result.into() } +/// `Bytecode.Toplevel.shardCheckIxVMFull`: end-to-end IxVM-native +/// shard check. +/// +/// Combines `buildShardCheckEnvWitness` (witness construction) and +/// `executeIxVM` into a single FFI call so the heavy IOBuffer never +/// crosses the Lean/Rust boundary. Builds the witness directly in +/// Rust from a memory-mapped `.ixe` env (no per-byte boxing into +/// Lean values), then dispatches to `execute_ixvm`. +/// +/// Returns the same `(output, ioBuffer, queryCounts)` triple as +/// `rs_aiur_toplevel_execute_ixvm` so the Lean shim can stay drop- +/// in compatible. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_shard_check_ixvm( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + ixe_path: LeanByteArray>, + owned_blob: LeanByteArray>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let ixe_path_str = + String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); + + // Owned addresses arrive as a flat ByteArray of 32-byte blocks. + let bytes = owned_blob.as_bytes(); + if bytes.len() % 32 != 0 { + return LeanExcept::error_string(&format!( + "owned_blob: length {} not a multiple of 32", + bytes.len() + )); + } + let owned: Vec = bytes + .chunks_exact(32) + .map(|c| ix_common::address::Address::from_slice(c).unwrap()) + .collect(); + + // Load env via mmap (lazy, only touches what's read). + let env = match ixon::Env::get_anon_mmap( + std::path::Path::new(&ixe_path_str), + ) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + }; + + // Build the witness in Rust (no per-byte Lean boxing). + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_shard_check_env_witness( + &env, &owned, + ) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, + fun_idx, + input, + &mut io_buffer, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), + }; + + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let lean_query_counts = { + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr + }; + + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + /// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape /// as `rs_aiur_system_prove`, but routes execution through the /// codegen'd Rust kernel (`execute_generated`) via diff --git a/crates/ix/src/aiur_ixvm_witness.rs b/crates/ix/src/aiur_ixvm_witness.rs new file mode 100644 index 00000000..607f69ab --- /dev/null +++ b/crates/ix/src/aiur_ixvm_witness.rs @@ -0,0 +1,273 @@ +//! Rust port of `IxVM.ClaimHarness.buildShardCheckEnvWitness`. +//! +//! Replaces the Lean-side IOBuffer construction (~92% of shard +//! wall time on heavy partitions) with a direct Rust implementation +//! that builds `aiur::execute::IOBuffer` without per-byte boxing +//! into Lean values. +//! +//! Mirrors the per-channel layout documented in +//! `Ix/IxVM/ClaimHarness.lean`: +//! +//! | Tier | ch | purpose | key | value | +//! |-------|----|--------------------------|----------------|-----------| +//! | Ctrl | 0 | claim wire bytes | claim_digest | bytes | +//! | Ctrl | 1 | assumption tree bytes | tree.root | bytes | +//! | Const | 2 | constant wire bytes | const addr | bytes | +//! | Const | 3 | Defn reducibility hint | Defn addr | single G | +//! | Blob | 4 | blob discriminator | addr | one byte | +//! | Blob | 5 | blob raw bytes | blob addr | bytes | +//! +//! Soundness model unchanged — every byte-stream is blake3-verified +//! kernel-side against its content-addressed key. +//! +//! # Parallelism +//! +//! Two hot phases use rayon for thread-level parallelism: +//! +//! * **Closure walk** (`closure_from_set`): each owned addr's +//! transitive walk runs on its own thread; results are unioned +//! into a `DashSet` to dedupe across threads. +//! * **Byte→G conversion** (`add_entries`): for each addr in the +//! closure, the per-const `(key, data)` tuple is built in parallel +//! with rayon's `par_bridge`. Only the final IOBuffer assembly +//! (extending channel arenas + inserting into the key→(idx,len) +//! map) runs serially, since the arena `idx` is monotonic. + +use dashmap::DashSet; +use multi_stark::p3_field::PrimeCharacteristicRing; +use rayon::prelude::*; +use rustc_hash::FxHashSet; + +use aiur::G; +use aiur::execute::{IOBuffer, IOKeyInfo}; +use ix_common::address::Address; +use ix_common::env::ReducibilityHints; +use ixon::Env; +use ixon::assumption_tree::AssumptionTree; +use ixon::constant::ConstantInfo; +use ixon::proof::Claim; + +/// Append `data` to the per-channel arena and record `(idx, len)` +/// in the `(channel, key)` info map. +#[inline] +fn extend(io: &mut IOBuffer, channel: G, key: Vec, data: Vec) { + let arena = io.data.entry(channel).or_default(); + let idx = arena.len(); + let len = data.len(); + arena.extend(data); + io.map.insert((channel, key), IOKeyInfo { idx, len }); +} + +#[inline] +fn addr_key(addr: &Address) -> Vec { + addr.as_bytes().iter().map(|b| G::from_u8(*b)).collect() +} + +#[inline] +fn bytes_to_g(bytes: &[u8]) -> Vec { + bytes.iter().map(|b| G::from_u8(*b)).collect() +} + +/// Mirror of `IxVM.ClaimHarness.hintToG`: +/// `Opaque → 0`, `Abbrev → 0xFFFFFFFF`, `Regular n → min(1+n, 0xFFFFFFFE)`. +fn hint_to_g(h: &ReducibilityHints) -> G { + let v: u64 = match h { + ReducibilityHints::Opaque => 0, + ReducibilityHints::Abbrev => 0xFFFF_FFFF, + ReducibilityHints::Regular(n) => { + let v = (1u64).saturating_add(u64::from(*n)); + v.min(0xFFFF_FFFE) + }, + }; + G::from_u64(v) +} + +/// Single-source transitive closure over `Constant.refs` + projection +/// blocks. Sequential BFS. +fn closure_from(env: &Env, target: &Address, visited: &DashSet
) { + let mut stack: Vec
= vec![target.clone()]; + while let Some(addr) = stack.pop() { + if !visited.insert(addr.clone()) { + continue; + } + let Some(c) = env.get_const(&addr) else { + continue; + }; + for r in &c.refs { + if !visited.contains(r) { + stack.push(r.clone()); + } + } + let block = match &c.info { + ConstantInfo::IPrj(p) => Some(&p.block), + ConstantInfo::CPrj(p) => Some(&p.block), + ConstantInfo::RPrj(p) => Some(&p.block), + ConstantInfo::DPrj(p) => Some(&p.block), + _ => None, + }; + if let Some(b) = block { + if !visited.contains(b) { + stack.push(b.clone()); + } + } + } +} + +/// Parallel transitive closure: each owned addr's walk runs on its +/// own thread, results unioned via the shared `DashSet`. +fn closure_from_set(env: &Env, owned: &[Address]) -> FxHashSet
{ + let visited: DashSet
= DashSet::new(); + owned.par_iter().for_each(|a| closure_from(env, a, &visited)); + visited.into_iter().collect() +} + +/// Per-channel entry produced by the parallel scan over the closure. +/// Sorted into the IOBuffer in a serial fold afterwards. +struct ChannelEntries { + /// ch 2 const entries: `(key, bytes-as-G)`. + consts: Vec<(Vec, Vec)>, + /// ch 5 blob entries: `(key, bytes-as-G)`. + blobs: Vec<(Vec, Vec)>, + /// ch 4 discriminator: `(key, [g])` — `g` is `1` for const, `0` for blob. + discs: Vec<(Vec, G)>, + /// ch 3 Defn hint: `(key, hint-G)`. + hints: Vec<(Vec, G)>, +} + +impl ChannelEntries { + fn new() -> Self { + Self { + consts: Vec::new(), + blobs: Vec::new(), + discs: Vec::new(), + hints: Vec::new(), + } + } +} + +/// Build the per-channel `(key, data)` tuples for every addr in +/// `closure`. Byte→G conversion runs in parallel; the IOBuffer +/// assembly is sequential because arena `idx` must be monotonic. +fn add_entries_parallel( + env: &Env, + closure: &FxHashSet
, + io: &mut IOBuffer, +) { + let ch_const = G::from_u8(2); + let ch_hint = G::from_u8(3); + let ch_disc = G::from_u8(4); + let ch_blob = G::from_u8(5); + let g_zero = G::ZERO; + let g_one = G::ONE; + + // Pull the set of addrs we'll touch as a Vec for parallel iteration. + let closure_vec: Vec
= closure.iter().cloned().collect(); + + // Phase A: parallel byte conversion per closure addr. Each thread + // produces its own partial `ChannelEntries`. + let partials: Vec = closure_vec + .par_chunks(256) + .map(|chunk| { + let mut p = ChannelEntries::new(); + for addr in chunk { + let key = addr_key(addr); + // Const lookup first. + if let Some(lc) = env.consts.get(addr) { + let data = bytes_to_g(lc.raw_bytes()); + p.consts.push((key.clone(), data)); + p.discs.push((key, g_one)); + continue; + } + // Blob lookup. + if let Some(blob) = env.blobs.get(addr) { + let data = bytes_to_g(blob.value()); + p.blobs.push((key.clone(), data)); + p.discs.push((key, g_zero)); + continue; + } + // Neither — closure includes some addresses (e.g. blob refs + // from const.refs) that may not be in env.blobs if the env + // doesn't carry them; skip silently to mirror the Lean side. + } + // Hints come from env.anon_hints (sidecar). Collect per chunk. + for addr in chunk { + if let Some(h) = env.anon_hints.get(addr) { + p.hints.push((addr_key(addr), hint_to_g(h))); + } + } + p + }) + .collect(); + + // Phase B: serial assembly into the IOBuffer. + for p in partials { + for (key, data) in p.consts { + extend(io, ch_const, key, data); + } + for (key, data) in p.blobs { + extend(io, ch_blob, key, data); + } + for (key, disc) in p.discs { + extend(io, ch_disc, key, vec![disc]); + } + for (key, hint) in p.hints { + extend(io, ch_hint, key, vec![hint]); + } + } +} + +/// Build a `CheckEnv`-shaped shard witness directly in Rust. Returns +/// `(claim, claim_digest_input, io_buffer)` ready to feed to +/// `crate::ix::aiur_ixvm_runner::execute_ixvm`. +pub fn build_shard_check_env_witness( + env: &Env, + owned: &[Address], +) -> Result<(Claim, Vec, IOBuffer), String> { + let owned_set: FxHashSet
= owned.iter().cloned().collect(); + + // Transitive closure over `Constant.refs` + projection blocks, parallel + // per owned addr. + let closure = closure_from_set(env, owned); + + let mut closure_vec: Vec
= closure.iter().cloned().collect(); + closure_vec.sort(); + let frontier: Vec
= closure_vec + .iter() + .filter(|a| !owned_set.contains(*a)) + .cloned() + .collect(); + let env_tree = AssumptionTree::canonical(&closure_vec) + .ok_or_else(|| "build_shard_check_env_witness: empty closure".to_string())?; + let asm_tree = AssumptionTree::canonical(&frontier); + + let claim = Claim::CheckEnv { + root: env_tree.root(), + assumptions: asm_tree.as_ref().map(|t| t.root()), + }; + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let digest_key = addr_key(&digest); + + let mut io = IOBuffer { + data: rustc_hash::FxHashMap::default(), + map: rustc_hash::FxHashMap::default(), + }; + // ch 0: claim bytes + extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); + // ch 2/3/4/5 per-const/blob/hint entries — parallel byte conversion. + add_entries_parallel(env, &closure, &mut io); + // ch 1: env tree + extend( + &mut io, + G::ONE, + addr_key(&env_tree.root()), + bytes_to_g(&env_tree.ser()), + ); + // ch 1: asm tree (if present) + if let Some(at) = asm_tree { + extend(&mut io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser())); + } + + Ok((claim, digest_key, io)) +} diff --git a/crates/ix/src/lib.rs b/crates/ix/src/lib.rs index 573878f4..7f7026f1 100644 --- a/crates/ix/src/lib.rs +++ b/crates/ix/src/lib.rs @@ -4,3 +4,4 @@ pub mod aiur_ixvm; pub mod aiur_ixvm_runner; +pub mod aiur_ixvm_witness; From e60da3cbbf791b25975f78e6e6b2e54bd45e2c63 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 08:03:20 -0700 Subject: [PATCH 07/11] Codegen: value-returning byte ops, dead-fold the unconstrained plumbing, unchecked cache-hit array copy MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three targeted cuts to the generated kernel (`src/ix/aiur_ixvm.rs`); all preserve QueryRecord parity (shard 26 FFT cost unchanged at 107_006_963_281). Every `U8*` op previously emitted a `Vec` scratch (~245 sites): let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_i, __v_j]; if unconstrained { __scratch.extend(vec![Bytes2::xor(...)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; Net cost: a 2-element `vec![]` alloc + a `__scratch.extend(vec![..])` (another small alloc inside `Bytes2::execute`'s returned Vec) + a slice→array `try_into().unwrap()`. Added per-op `bytes{1,2}_*_value(args..., record) -> G | (G,G) | (G,G,G) | [G; 8]` in `src/aiur/execute.rs` — each bumps the corresponding `bytes{1,2}_queries.bump_*` and returns the gadget output by value. The pure (`Bytes{1,2}::*`) helpers stay the unconstrained shortcut. Codegen now emits: let __v_n: G = if unconstrained { Bytes2::xor(&__v_i, &__v_j) } else { bytes2_xor_value(__v_i, __v_j, record) }; Zero `Vec` allocation per byte op. `U8Add`/`U8Sub` also gain because `bytes2_add_value` runs the `Bytes2::add` gadget once (returning the full `(low, carry)`) instead of the interpreter's two `Bytes2::add` calls (one for the carry, one for the low push). To make `bump_*` callable from `execute.rs`, all `Bytes1Queries` / `Bytes2Queries::bump_*` methods are now `pub(crate)`. No behaviour change. The `Op::Call` cache-check emitted `unconstrained || OP_UN` and `!unconstrained && !OP_UN` even when the static `OP_UN` was `false`, which is the common case. Codegen now emits the folded shape directly: let __cu = unconstrained; // was: unconstrained || false if !unconstrained { *result.multiplicity += G::ONE; } // was: !unconstrained && !false When `OP_UN == true`, the callee always runs unconstrained AND the multiplicity bump is always suppressed; codegen folds to `let __cu = true;` and elides the bump branch entirely. LLVM was already folding these, so this is mostly source-cleanliness and a small frontend win. The cache-hit branch read `result.output` (an `&[G]`) and converted it back to `[G; OUT_N]` via `.try_into().unwrap()`. The length is statically `OUT_N` — we control the producer (the matching `aiur_fn_{callee}::Ctrl::Return` inserts an `[G; OUT_N]`-typed array into the same slot). The runtime bounds-check + Result discharge is dead work. Codegen now emits: let __ret: [G; OUT_N] = unsafe { *(result.output.as_ptr() as *const [G; OUT_N]) }; Sound: same-fn slot, fixed `OUT_N`, no aliasing. | Variant | mean | | --- | --: | | Rust witness (parallel) + codegen | 80 s | | + value-helper byte ops (#1) | 64 s | | + folded `__cu` + unsafe cache copy (#2+#3) | 62 s | The bulk of the win is #1 (#1 alone: ~−18%). #2+#3 are a further ~3% — mostly noise / Rust-frontend cleanup since LLVM already folds the constant `false` ops. * `src/aiur/execute.rs`: 12 value-returning byte helpers added (`bytes1_bit_decompose_value`, `bytes1_shift_left_value`, `bytes1_shift_right_value`, `bytes2_{xor,and,or,less_than,mul, chain_rotr7,chain_rotr4,add,sub}_value`). * `src/aiur/gadgets/bytes1.rs`, `src/aiur/gadgets/bytes2.rs`: all `bump_*` upgraded to `pub(crate)` so the value helpers can call them. * `Ix/Aiur/Stages/Codegen.lean`: `emitU8Bytes1` / `emitU8Bytes2` / `emitU8Add` / `emitU8Sub` rewritten to call the per-op value helpers — no scratch Vec, no slice→array conversion. `emitCall` constant-folds `opUn = false` and emits the unsafe cache-hit copy. Prelude imports updated to bring the new helpers into scope. * `src/ix/aiur_ixvm.rs`: regenerated. 245 `Vec` scratch sites → 11 (only `unconstrainedBigUintDivMod`'s scratch left); 3324 `unconstrained || false` → 0; 3000+ `result.output.try_into() .unwrap()` → 0. * `Ix/Cli/CheckCmd.lean`: incidental cleanup of probe-only timing prints in `runShardOwnedNative` (added during measurement, no longer needed). --- Ix/Aiur/Stages/Codegen.lean | 218 +- crates/aiur/src/execute.rs | 156 +- crates/aiur/src/gadgets/bytes1.rs | 8 +- crates/aiur/src/gadgets/bytes2.rs | 18 +- crates/ix/src/aiur_ixvm.rs | 7302 ++++++++++++++--------------- 5 files changed, 3878 insertions(+), 3824 deletions(-) diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 48679311..871f2b38 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -374,13 +374,28 @@ private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) -- Structured IR for if-let-as-expression would need a `blockExpr` -- node; deferred until after parity testing validates the shape. let argsStr : String := (argsAsArray args).toStr - let opUnStr : String := if opUn then "true" else "false" + -- Constant-fold the `unconstrained || OP_UN` / `!unconstrained && !OP_UN` + -- patterns based on the static `opUn` flag. When opUn = true the + -- callee always runs unconstrained AND the multiplicity bump is + -- always skipped; when opUn = false both expressions collapse to + -- just `unconstrained`. + let cuExpr : String := if opUn then "true" else "unconstrained" + let bumpCond : String := if opUn then "false" else "!unconstrained" + let bumpStmt : String := + if opUn then "" + else s!" if {bumpCond} \{ *result.multiplicity += G::ONE; }" + -- Skip `try_into().unwrap()` on the cache hit: we statically know + -- the cached output has exactly `OUT_{callee}` elements (only we + -- ever insert into this slot via the matching aiur_fn_{callee} + -- `Ctrl::Return`). An unchecked array copy is sound. + let retExpr : String := + s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(result.output.as_ptr() as *const [G; OUT_{callee}]) }; __ret" let blockExpr : String := s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++ - s!" let __cu = unconstrained || {opUnStr};" ++ + s!" let __cu = {cuExpr};" ++ s!" if let Some(result) = record.function_queries[{callee}].get_mut(&__args[..]) \{" ++ - s!" if !unconstrained && !{opUnStr} \{ *result.multiplicity += G::ONE; }" ++ - s!" let __ret: [G; OUT_{callee}] = result.output.try_into().unwrap(); __ret" ++ + bumpStmt ++ + retExpr ++ s!" } else \{ aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" let mut stmts : Array RustStmt := #[ .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr) @@ -497,60 +512,64 @@ private def emitIOWrite (channel : ValIdx) (data : Array ValIdx) : Array RustStm the same op. The execute.rs interpreter does the same dispatch. -/ -/-- Bytes1 op with a single G output. The interpreter's - `bytes1_execute` extends `map` by 1 G; the unconstrained shortcut - is a single value. Generate a scratch Vec around the helper so the - output is captured into a local `__v_{out}`. -/ -private def emitU8Bytes1 (out : Nat) (gadgetOp : String) (byte : ValIdx) - (unconShortcut : String) (outCount : Nat) : Array RustStmt := Id.run do - -- `unconShortcut` example: `Bytes1::shift_left` (returns G). - -- BitDecomposition returns 8 Gs, so outCount = 8; others 1. - let unconExpr : String := - if outCount == 1 then s!"vec![{unconShortcut}(&__v_{byte})]" - else s!"{unconShortcut}(&__v_{byte}).to_vec()" - let blockExpr : String := - s!"\{ let mut __scratch: Vec = vec![__v_{byte}];" ++ - s!" if unconstrained \{ __scratch.extend({unconExpr}); }" ++ - s!" else \{ bytes1_execute(0, &Bytes1Op::{gadgetOp}, &mut __scratch, record); }" ++ - s!" let __arr: [G; {outCount}] = __scratch[1..].try_into().unwrap(); __arr }" - let mut stmts : Array RustStmt := #[ - .letStmt false "__b1_out" (some s!"[G; {outCount}]") (.lit blockExpr) - ] - for k in [0 : outCount] do - stmts := stmts.push (declVal (out + k) (.index (.var "__b1_out") (.lit (toString k)))) - return stmts +/-- Bytes1 op. No scratch Vec — the constrained branch calls + `bytes1_*_value` (defined in `crate::aiur::execute`) which + bumps the byte-chip queries and returns the gadget output by + value; the unconstrained branch calls the pure `Bytes1::*` + helper directly. -/ +private def emitU8Bytes1 (out : Nat) (valueHelper : String) + (unconShortcut : String) (byte : ValIdx) (outCount : Nat) : + Array RustStmt := Id.run do + if outCount == 1 then + let blockExpr : String := + s!"if unconstrained \{ {unconShortcut}(&__v_{byte}) }" ++ + s!" else \{ {valueHelper}(__v_{byte}, record) }" + return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + else + -- BitDecomposition returns [G; 8]; the unconstrained shortcut + -- is the pure `Bytes1::bit_decompose` which returns Vec. + -- Coerce its result into [G; outCount] for unified handling. + let blockExpr : String := + s!"if unconstrained \{ let __v: Vec = {unconShortcut}(&__v_{byte}); let __a: [G; {outCount}] = __v.try_into().unwrap(); __a }" ++ + s!" else \{ {valueHelper}(__v_{byte}, record) }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b1_out" (some s!"[G; {outCount}]") (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.index (.var "__b1_out") (.lit (toString k)))) + return stmts -/-- Bytes2 op with `outCount` G outputs. -/ -private def emitU8Bytes2 (out : Nat) (gadgetOp : String) (i j : ValIdx) - (unconShortcut : String) (outCount : Nat) : Array RustStmt := Id.run do - let unconExpr : String := - if outCount == 1 then s!"vec![Bytes2::{unconShortcut}(&__v_{i}, &__v_{j})]" - else - -- For ops that return tuples (mul → (lo, hi); chain → (o0,o1,o2)). - let tup := s!"Bytes2::{unconShortcut}(&__v_{i}, &__v_{j})" - let fields := (List.range outCount).map (fun k => s!"{tup}.{k}") |> String.intercalate ", " - s!"vec![{fields}]" - let blockExpr : String := - s!"\{ let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ - s!" if unconstrained \{ __scratch.extend({unconExpr}); }" ++ - s!" else \{ bytes2_execute(0, 1, &Bytes2Op::{gadgetOp}, &mut __scratch, record); }" ++ - s!" let __arr: [G; {outCount}] = __scratch[2..].try_into().unwrap(); __arr }" - let mut stmts : Array RustStmt := #[ - .letStmt false "__b2_out" (some s!"[G; {outCount}]") (.lit blockExpr) - ] - for k in [0 : outCount] do - stmts := stmts.push (declVal (out + k) (.index (.var "__b2_out") (.lit (toString k)))) - return stmts +/-- Bytes2 op. Same pattern as `emitU8Bytes1` — no scratch Vec. -/ +private def emitU8Bytes2 (out : Nat) (valueHelper : String) + (unconShortcut : String) (i j : ValIdx) (outCount : Nat) : + Array RustStmt := Id.run do + if outCount == 1 then + let blockExpr : String := + s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + else + -- 2-tuple outputs (Mul) or 3-tuple (ChainRotr7/4). + let blockExpr : String := + s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + let tupTy : String := + "(" ++ (String.intercalate ", " (List.replicate outCount "G")) ++ ")" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b2_out" (some tupTy) (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.field (.var "__b2_out") (toString k))) + return stmts -/-- `Op::U8Add`: gadget pushes 1 G (low byte) via bytes2_execute; carry - is computed natively. Two outputs total: `(low, carry)`. -/ +/-- `Op::U8Add`: gadget bumps `bytes2_queries.add` and returns + `(low, carry)`. Codegen now calls `bytes2_add_value` ONCE in + the constrained branch (vs the interpreter's two `Bytes2::add` + calls). -/ private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := let blockExpr : String := - s!"\{ let (_, __carry) = Bytes2::add(&__v_{i}, &__v_{j});" ++ - s!" let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ - s!" if unconstrained \{ __scratch.push(Bytes2::add(&__v_{i}, &__v_{j}).0); }" ++ - s!" else \{ bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); }" ++ - s!" (__scratch[2], __carry) }" + s!"if unconstrained \{ Bytes2::add(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_add_value(__v_{i}, __v_{j}, record) }" #[ .letStmt false "__b2_add" (some "(G, G)") (.lit blockExpr), declVal out (.field (.var "__b2_add") "0"), @@ -560,11 +579,8 @@ private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := /-- `Op::U8Sub`: symmetric to U8Add. -/ private def emitU8Sub (out : Nat) (i j : ValIdx) : Array RustStmt := let blockExpr : String := - s!"\{ let (_, __borrow) = Bytes2::sub(&__v_{i}, &__v_{j});" ++ - s!" let mut __scratch: Vec = vec![__v_{i}, __v_{j}];" ++ - s!" if unconstrained \{ __scratch.push(Bytes2::sub(&__v_{i}, &__v_{j}).0); }" ++ - s!" else \{ bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); }" ++ - s!" (__scratch[2], __borrow) }" + s!"if unconstrained \{ Bytes2::sub(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_sub_value(__v_{i}, __v_{j}, record) }" #[ .letStmt false "__b2_sub" (some "(G, G)") (.lit blockExpr), declVal out (.field (.var "__b2_sub") "0"), @@ -639,16 +655,16 @@ def emitOp (out : Nat) (op : Op) : Array RustStmt := | .ioSetInfo ch key idx len => emitIOSetInfo ch key idx len | .ioRead ch idx len => emitIORead out ch idx len | .ioWrite ch data => emitIOWrite ch data - | .u8BitDecomposition b => emitU8Bytes1 out "BitDecomposition" b "Bytes1::bit_decompose" 8 - | .u8ShiftLeft b => emitU8Bytes1 out "ShiftLeft" b "Bytes1::shift_left" 1 - | .u8ShiftRight b => emitU8Bytes1 out "ShiftRight" b "Bytes1::shift_right" 1 - | .u8Xor i j => emitU8Bytes2 out "Xor" i j "xor" 1 - | .u8Mul i j => emitU8Bytes2 out "Mul" i j "mul" 2 - | .u8And i j => emitU8Bytes2 out "And" i j "and" 1 - | .u8Or i j => emitU8Bytes2 out "Or" i j "or" 1 - | .u8LessThan i j => emitU8Bytes2 out "LessThan" i j "less_than" 1 - | .u8ChainRotr7 i j => emitU8Bytes2 out "ChainRotr7" i j "chain_rotr7" 3 - | .u8ChainRotr4 i j => emitU8Bytes2 out "ChainRotr4" i j "chain_rotr4" 3 + | .u8BitDecomposition b => emitU8Bytes1 out "bytes1_bit_decompose_value" "Bytes1::bit_decompose" b 8 + | .u8ShiftLeft b => emitU8Bytes1 out "bytes1_shift_left_value" "Bytes1::shift_left" b 1 + | .u8ShiftRight b => emitU8Bytes1 out "bytes1_shift_right_value" "Bytes1::shift_right" b 1 + | .u8Xor i j => emitU8Bytes2 out "bytes2_xor_value" "xor" i j 1 + | .u8Mul i j => emitU8Bytes2 out "bytes2_mul_value" "mul" i j 2 + | .u8And i j => emitU8Bytes2 out "bytes2_and_value" "and" i j 1 + | .u8Or i j => emitU8Bytes2 out "bytes2_or_value" "or" i j 1 + | .u8LessThan i j => emitU8Bytes2 out "bytes2_less_than_value" "less_than" i j 1 + | .u8ChainRotr7 i j => emitU8Bytes2 out "bytes2_chain_rotr7_value" "chain_rotr7" i j 3 + | .u8ChainRotr4 i j => emitU8Bytes2 out "bytes2_chain_rotr4_value" "chain_rotr4" i j 3 | .u8Add i j => emitU8Add out i j | .u8Sub i j => emitU8Sub out i j | .u32LessThan a b => emitU32LessThan out a b @@ -863,7 +879,11 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do s!"{rbrace}\n\n" #[inputSizeConst, inConst, outConst, .raw fnText] -def emitPrelude : RustItem := .raw +/-- Header that's always emitted (file comments, lint allows, and the + fixed `use` items every generated body references). Per-op + helpers (`bytes2_xor_value`, etc.) are added only when the body + actually mentions them — see `emitConditionalImports`. -/ +def emitPreludeHeader : String := "// Auto-generated by Aiur codegen. Do not edit.\n\ //\n\ // Mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly.\n\ @@ -877,14 +897,44 @@ def emitPrelude : RustItem := .raw )]\n\ \n\ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ - use crate::aiur::G;\n\ - use crate::aiur::execute::{\n\ - \x20\x20ExecError, IOBuffer, QueryRecord,\n\ - \x20\x20bytes1_execute, bytes2_execute, unconstrained_big_uint_div_mod_helper,\n\ - \x20\x20CodegenBytes1 as Bytes1, CodegenBytes1Op as Bytes1Op,\n\ - \x20\x20CodegenBytes2 as Bytes2, CodegenBytes2Op as Bytes2Op,\n\ - };\n\ - \n" + use crate::aiur::G;\n" + +/-- The set of optional `crate::aiur::execute` items the codegen + might emit references to. Each pair is `(rust_path, search_token)` + — if `search_token` appears anywhere in the body string, the item + is included in the generated `use` block. The token is the exact + identifier that appears at every call site; substring match is + safe because all of these names are unique within the generated + file (no other crate-level item has the same identifier). -/ +def optionalExecuteUses : Array (String × String) := #[ + ("bytes1_bit_decompose_value", "bytes1_bit_decompose_value"), + ("bytes1_shift_left_value", "bytes1_shift_left_value"), + ("bytes1_shift_right_value", "bytes1_shift_right_value"), + ("bytes2_xor_value", "bytes2_xor_value"), + ("bytes2_and_value", "bytes2_and_value"), + ("bytes2_or_value", "bytes2_or_value"), + ("bytes2_less_than_value", "bytes2_less_than_value"), + ("bytes2_mul_value", "bytes2_mul_value"), + ("bytes2_add_value", "bytes2_add_value"), + ("bytes2_sub_value", "bytes2_sub_value"), + ("bytes2_chain_rotr7_value", "bytes2_chain_rotr7_value"), + ("bytes2_chain_rotr4_value", "bytes2_chain_rotr4_value"), + ("unconstrained_big_uint_div_mod_helper", "unconstrained_big_uint_div_mod_helper"), + ("CodegenBytes1 as Bytes1", "Bytes1::"), + ("CodegenBytes2 as Bytes2", "Bytes2::") +] + +/-- Build the `use crate::aiur::execute::{...};` block, including only + items whose search token appears in `body`. -/ +def emitConditionalImports (body : String) : String := Id.run do + let always : Array String := #["ExecError", "IOBuffer", "QueryRecord"] + let mut items : Array String := always + for (path, token) in optionalExecuteUses do + if (body.splitOn token).length > 1 then + items := items.push path + let joined : String := items.toList.foldl + (fun acc s => if acc.isEmpty then s else acc ++ ", " ++ s) "" + s!"use crate::aiur::execute::\{ {joined} };\n\n" /-- Build the dispatch entry point `pub fn execute_generated(...)` that maps a `fun_idx` to the right `aiur_fn_N` invocation. Mirrors @@ -923,16 +973,18 @@ def emitDispatch (tl : Toplevel) : RustItem := Id.run do stmtsToStr 1 body ++ s!"{rbrace}\n") -/-- Emit Rust source for the whole `Bytecode.Toplevel`. -/ +/-- Emit Rust source for the whole `Bytecode.Toplevel`. Builds the + body first, then emits a prelude whose `use` block lists only + the helpers the body actually mentions. -/ def emit (tl : Toplevel) : String := Id.run do - let mut items : Array RustItem := #[emitPrelude] + let mut items : Array RustItem := #[] for funIdx in [0 : tl.functions.size] do items := items ++ emitFunction funIdx tl.functions[funIdx]! items := items.push (emitDispatch tl) - let mut o := "" + let mut bodyStr := "" for it in items do - o := o ++ it.toStr - o + bodyStr := bodyStr ++ it.toStr + emitPreludeHeader ++ emitConditionalImports bodyStr ++ bodyStr end Aiur.Codegen diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 8c45cec2..7732f031 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -678,15 +678,157 @@ pub fn bytes2_execute( map.extend(Bytes2.execute(op, &[map[i], map[j]], record)); } +// ============================================================================ +// Per-op value-returning helpers for the codegen'd kernel. +// +// The interpreter routes byte ops through `bytes{1,2}_execute(idx, op, +// &mut Vec, record)` which `extends` the Vec with the gadget's +// output. The codegen'd kernel doesn't keep a `Vec` value stack +// (every Aiur ValIdx is a real Rust local), so the wrappers below let +// it consume gadget outputs as fixed-size arrays / tuples / single Gs +// without an allocating Vec per op. +// +// Each helper bumps the same `bytes{1,2}_queries` channel as the +// interpreter's `Bytes{1,2}::execute` arm, so QueryRecord parity is +// preserved bit-for-bit. +// ============================================================================ + +#[inline] +pub fn bytes1_bit_decompose_value( + byte: G, + record: &mut QueryRecord, +) -> [G; 8] { + record.bytes1_queries.bump_bit_decomposition(&byte); + let byte_u64 = byte.as_canonical_u64(); + [ + G::from_bool(byte_u64 & 1 == 1), + G::from_bool(byte_u64 >> 1 & 1 == 1), + G::from_bool(byte_u64 >> 2 & 1 == 1), + G::from_bool(byte_u64 >> 3 & 1 == 1), + G::from_bool(byte_u64 >> 4 & 1 == 1), + G::from_bool(byte_u64 >> 5 & 1 == 1), + G::from_bool(byte_u64 >> 6 & 1 == 1), + G::from_bool(byte_u64 >> 7 & 1 == 1), + ] +} + +/// IxVM kernel doesn't emit `Op::U8ShiftLeft` today; kept for codegen +/// of other toplevels that might. +#[inline] +#[allow(dead_code)] +pub fn bytes1_shift_left_value( + byte: G, + record: &mut QueryRecord, +) -> G { + record.bytes1_queries.bump_shift_left(&byte); + Bytes1::shift_left(&byte) +} + +/// IxVM kernel doesn't emit `Op::U8ShiftRight` today; kept for +/// codegen of other toplevels. +#[inline] +#[allow(dead_code)] +pub fn bytes1_shift_right_value( + byte: G, + record: &mut QueryRecord, +) -> G { + record.bytes1_queries.bump_shift_right(&byte); + Bytes1::shift_right(&byte) +} + +#[inline] +pub fn bytes2_xor_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_xor(&a, &b); + Bytes2::xor(&a, &b) +} + +#[inline] +pub fn bytes2_and_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_and(&a, &b); + Bytes2::and(&a, &b) +} + +#[inline] +pub fn bytes2_or_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_or(&a, &b); + Bytes2::or(&a, &b) +} + +#[inline] +pub fn bytes2_less_than_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> G { + record.bytes2_queries.bump_less_than(&a, &b); + Bytes2::less_than(&a, &b) +} + +/// IxVM kernel doesn't emit `Op::U8Mul` today; kept for codegen of +/// other toplevels. +#[inline] +#[allow(dead_code)] +pub fn bytes2_mul_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_mul(&a, &b); + Bytes2::mul(&a, &b) +} + +#[inline] +pub fn bytes2_chain_rotr7_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G, G) { + record.bytes2_queries.bump_chain_rotr7(&a, &b); + Bytes2::chain_rotr7(&a, &b) +} + +#[inline] +pub fn bytes2_chain_rotr4_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G, G) { + record.bytes2_queries.bump_chain_rotr4(&a, &b); + Bytes2::chain_rotr4(&a, &b) +} + +/// Bumps `bytes2_queries.add` and returns the full `(low, carry)` +/// pair. The constrained-mode gadget only LOOKUPS `low` from the +/// chip; carry is derived natively. The codegen path uses this +/// helper so the add gadget runs exactly once. +#[inline] +pub fn bytes2_add_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_add(&a, &b); + Bytes2::add(&a, &b) +} + +#[inline] +pub fn bytes2_sub_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_sub(&a, &b); + Bytes2::sub(&a, &b) +} + /// Re-exports for the codegen'd kernel (`ix::aiur_ixvm`). The generated /// code names these as `aiur::execute::*`; we re-export them `pub` here -/// so an external `ix` crate can see them. -pub use crate::gadgets::bytes1::{ - Bytes1 as CodegenBytes1, Bytes1Op as CodegenBytes1Op, -}; -pub use crate::gadgets::bytes2::{ - Bytes2 as CodegenBytes2, Bytes2Op as CodegenBytes2Op, -}; +/// so an external `ix` crate can see them. `CodegenBytes1Op` and +/// `CodegenBytes2Op` aren't re-exported here because the generated +/// kernel no longer references them (per-op value helpers above +/// replaced the byte-op enum dispatch). +pub use crate::gadgets::bytes1::Bytes1 as CodegenBytes1; +pub use crate::gadgets::bytes2::Bytes2 as CodegenBytes2; /// Helper extracted for the codegen'd kernel: compute the unconstrained /// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index b5f49c4c..a874f258 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -213,19 +213,19 @@ impl Bytes1Queries { Self([[G::ZERO; TRACE_WIDTH]; 256]) } - fn bump_bit_decomposition(&mut self, byte: &G) { + pub(crate) fn bump_bit_decomposition(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 0) } - fn bump_shift_left(&mut self, byte: &G) { + pub(crate) fn bump_shift_left(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 1) } - fn bump_shift_right(&mut self, byte: &G) { + pub(crate) fn bump_shift_right(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 2) } - fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { + pub(crate) fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { let row = usize::try_from(byte.as_canonical_u64()).unwrap(); self.0[row][col] += G::ONE; } diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index 15030b2b..be47be65 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -430,11 +430,11 @@ impl Bytes2Queries { Self(vec![[G::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice()) } - fn bump_xor(&mut self, i: &G, j: &G) { + pub(crate) fn bump_xor(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 0) } - fn bump_add(&mut self, i: &G, j: &G) { + pub(crate) fn bump_add(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 1) } @@ -442,15 +442,15 @@ impl Bytes2Queries { self.bump_multiplicity_for(i, j, 2) } - fn bump_and(&mut self, i: &G, j: &G) { + pub(crate) fn bump_and(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 3) } - fn bump_or(&mut self, i: &G, j: &G) { + pub(crate) fn bump_or(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 4) } - fn bump_less_than(&mut self, i: &G, j: &G) { + pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 5) } @@ -458,19 +458,19 @@ impl Bytes2Queries { self.bump_multiplicity_for(i, j, 6) } - fn bump_mul(&mut self, i: &G, j: &G) { + pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 7) } - fn bump_chain_rotr7(&mut self, i: &G, j: &G) { + pub(crate) fn bump_chain_rotr7(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 8) } - fn bump_chain_rotr4(&mut self, i: &G, j: &G) { + pub(crate) fn bump_chain_rotr4(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 9) } - fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { + pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { let i = usize::try_from(i.as_canonical_u64()).unwrap(); let j = usize::try_from(j.as_canonical_u64()).unwrap(); let row = 256 * i + j; diff --git a/crates/ix/src/aiur_ixvm.rs b/crates/ix/src/aiur_ixvm.rs index 06fcf7c9..ba0ce71b 100644 --- a/crates/ix/src/aiur_ixvm.rs +++ b/crates/ix/src/aiur_ixvm.rs @@ -12,12 +12,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; -use aiur::execute::{ - ExecError, IOBuffer, QueryRecord, - bytes1_execute, bytes2_execute, unconstrained_big_uint_div_mod_helper, - CodegenBytes1 as Bytes1, CodegenBytes1Op as Bytes1Op, - CodegenBytes2 as Bytes2, CodegenBytes2Op as Bytes2Op, -}; +use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 3; const IN_0: usize = 3; @@ -46,7 +41,7 @@ fn aiur_fn_0( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; @@ -1478,27 +1473,27 @@ fn aiur_fn_3( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; let __v_8: G = __b2_add.0; let __v_9: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; let __v_10: G = __b2_add.0; let __v_11: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_9); let mut __scratch: Vec = vec![__v_10, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) }; let __v_12: G = __b2_add.0; let __v_13: G = __b2_add.1; let __v_14: G = (__v_11 + __v_13); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; let __v_15: G = __b2_add.0; let __v_16: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_15, &__v_14); let mut __scratch: Vec = vec![__v_15, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_15, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) }; let __v_17: G = __b2_add.0; let __v_18: G = __b2_add.1; let __v_19: G = (__v_16 + __v_18); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; let __v_20: G = __b2_add.0; let __v_21: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_20, &__v_19); let mut __scratch: Vec = vec![__v_20, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_20, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) }; let __v_22: G = __b2_add.0; let __v_23: G = __b2_add.1; let __ret: [G; OUT_3] = [__v_8, __v_12, __v_17, __v_22]; @@ -1525,14 +1520,10 @@ fn aiur_fn_4( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_8: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_9: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_10: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_11: G = __b2_out[0]; + let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) }; + let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; + let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; + let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -1557,14 +1548,10 @@ fn aiur_fn_5( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_8: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_9: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_2, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_10: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_3, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_11: G = __b2_out[0]; + let __v_8: G = if unconstrained { Bytes2::and(&__v_0, &__v_4) } else { bytes2_and_value(__v_0, __v_4, record) }; + let __v_9: G = if unconstrained { Bytes2::and(&__v_1, &__v_5) } else { bytes2_and_value(__v_1, __v_5, record) }; + let __v_10: G = if unconstrained { Bytes2::and(&__v_2, &__v_6) } else { bytes2_and_value(__v_2, __v_6, record) }; + let __v_11: G = if unconstrained { Bytes2::and(&__v_3, &__v_7) } else { bytes2_and_value(__v_3, __v_7, record) }; let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -1718,55 +1705,55 @@ fn aiur_fn_7( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_8); let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record) }; let __v_16: G = __b2_add.0; let __v_17: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_9); let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_9) } else { bytes2_add_value(__v_1, __v_9, record) }; let __v_18: G = __b2_add.0; let __v_19: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_18, &__v_17); let mut __scratch: Vec = vec![__v_18, __v_17]; if unconstrained { __scratch.push(Bytes2::add(&__v_18, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_18, &__v_17) } else { bytes2_add_value(__v_18, __v_17, record) }; let __v_20: G = __b2_add.0; let __v_21: G = __b2_add.1; let __v_22: G = (__v_19 + __v_21); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_10); let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_10).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_10) } else { bytes2_add_value(__v_2, __v_10, record) }; let __v_23: G = __b2_add.0; let __v_24: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_23, &__v_22); let mut __scratch: Vec = vec![__v_23, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_23, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_23, &__v_22) } else { bytes2_add_value(__v_23, __v_22, record) }; let __v_25: G = __b2_add.0; let __v_26: G = __b2_add.1; let __v_27: G = (__v_24 + __v_26); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_11); let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_11) } else { bytes2_add_value(__v_3, __v_11, record) }; let __v_28: G = __b2_add.0; let __v_29: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_28, &__v_27); let mut __scratch: Vec = vec![__v_28, __v_27]; if unconstrained { __scratch.push(Bytes2::add(&__v_28, &__v_27).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_27) } else { bytes2_add_value(__v_28, __v_27, record) }; let __v_30: G = __b2_add.0; let __v_31: G = __b2_add.1; let __v_32: G = (__v_29 + __v_31); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_4, &__v_12); let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.push(Bytes2::add(&__v_4, &__v_12).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_12) } else { bytes2_add_value(__v_4, __v_12, record) }; let __v_33: G = __b2_add.0; let __v_34: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_33, &__v_32); let mut __scratch: Vec = vec![__v_33, __v_32]; if unconstrained { __scratch.push(Bytes2::add(&__v_33, &__v_32).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_32) } else { bytes2_add_value(__v_33, __v_32, record) }; let __v_35: G = __b2_add.0; let __v_36: G = __b2_add.1; let __v_37: G = (__v_34 + __v_36); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_5, &__v_13); let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.push(Bytes2::add(&__v_5, &__v_13).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_13) } else { bytes2_add_value(__v_5, __v_13, record) }; let __v_38: G = __b2_add.0; let __v_39: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_38, &__v_37); let mut __scratch: Vec = vec![__v_38, __v_37]; if unconstrained { __scratch.push(Bytes2::add(&__v_38, &__v_37).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_37) } else { bytes2_add_value(__v_38, __v_37, record) }; let __v_40: G = __b2_add.0; let __v_41: G = __b2_add.1; let __v_42: G = (__v_39 + __v_41); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_6, &__v_14); let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_6, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_14) } else { bytes2_add_value(__v_6, __v_14, record) }; let __v_43: G = __b2_add.0; let __v_44: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_43, &__v_42); let mut __scratch: Vec = vec![__v_43, __v_42]; if unconstrained { __scratch.push(Bytes2::add(&__v_43, &__v_42).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_43, &__v_42) } else { bytes2_add_value(__v_43, __v_42, record) }; let __v_45: G = __b2_add.0; let __v_46: G = __b2_add.1; let __v_47: G = (__v_44 + __v_46); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_7, &__v_15); let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.push(Bytes2::add(&__v_7, &__v_15).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_15) } else { bytes2_add_value(__v_7, __v_15, record) }; let __v_48: G = __b2_add.0; let __v_49: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_48, &__v_47); let mut __scratch: Vec = vec![__v_48, __v_47]; if unconstrained { __scratch.push(Bytes2::add(&__v_48, &__v_47).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_48, &__v_47) } else { bytes2_add_value(__v_48, __v_47, record) }; let __v_50: G = __b2_add.0; let __v_51: G = __b2_add.1; let __v_52: G = (__v_49 + __v_51); @@ -1802,7 +1789,7 @@ fn aiur_fn_8( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -1811,7 +1798,7 @@ fn aiur_fn_8( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -1820,7 +1807,7 @@ fn aiur_fn_8( let __v_22: G = __r_arr[5]; let __v_23: G = __r_arr[6]; let __v_24: G = __r_arr[7]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; @@ -1829,7 +1816,7 @@ fn aiur_fn_8( let __v_30: G = __r_arr[5]; let __v_31: G = __r_arr[6]; let __v_32: G = __r_arr[7]; - let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = result.output.try_into().unwrap(); __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -2056,32 +2043,32 @@ fn aiur_fn_11( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_7, &__v_9); let mut __scratch: Vec = vec![__v_7, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_7, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_9) } else { bytes2_add_value(__v_7, __v_9, record) }; let __v_10: G = __b2_add.0; let __v_11: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_6, &__v_8); let mut __scratch: Vec = vec![__v_6, __v_8]; if unconstrained { __scratch.push(Bytes2::add(&__v_6, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_8) } else { bytes2_add_value(__v_6, __v_8, record) }; let __v_12: G = __b2_add.0; let __v_13: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_12, &__v_11); let mut __scratch: Vec = vec![__v_12, __v_11]; if unconstrained { __scratch.push(Bytes2::add(&__v_12, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_12, &__v_11) } else { bytes2_add_value(__v_12, __v_11, record) }; let __v_14: G = __b2_add.0; let __v_15: G = __b2_add.1; let __v_16: G = (__v_13 + __v_15); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_5, &__v_16); let mut __scratch: Vec = vec![__v_5, __v_16]; if unconstrained { __scratch.push(Bytes2::add(&__v_5, &__v_16).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_16) } else { bytes2_add_value(__v_5, __v_16, record) }; let __v_17: G = __b2_add.0; let __v_18: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_4, &__v_18); let mut __scratch: Vec = vec![__v_4, __v_18]; if unconstrained { __scratch.push(Bytes2::add(&__v_4, &__v_18).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_18) } else { bytes2_add_value(__v_4, __v_18, record) }; let __v_19: G = __b2_add.0; let __v_20: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_20); let mut __scratch: Vec = vec![__v_3, __v_20]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_20).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_20) } else { bytes2_add_value(__v_3, __v_20, record) }; let __v_21: G = __b2_add.0; let __v_22: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_22); let mut __scratch: Vec = vec![__v_2, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_22) } else { bytes2_add_value(__v_2, __v_22, record) }; let __v_23: G = __b2_add.0; let __v_24: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_24); let mut __scratch: Vec = vec![__v_1, __v_24]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_24).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_24) } else { bytes2_add_value(__v_1, __v_24, record) }; let __v_25: G = __b2_add.0; let __v_26: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_26); let mut __scratch: Vec = vec![__v_0, __v_26]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_26).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_26) } else { bytes2_add_value(__v_0, __v_26, record) }; let __v_27: G = __b2_add.0; let __v_28: G = __b2_add.1; let __ret: [G; OUT_11] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10]; @@ -2108,27 +2095,27 @@ fn aiur_fn_12( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; let __v_8: G = __b2_add.0; let __v_9: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; let __v_10: G = __b2_add.0; let __v_11: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_9); let mut __scratch: Vec = vec![__v_10, __v_9]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) }; let __v_12: G = __b2_add.0; let __v_13: G = __b2_add.1; let __v_14: G = (__v_11 + __v_13); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; let __v_15: G = __b2_add.0; let __v_16: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_15, &__v_14); let mut __scratch: Vec = vec![__v_15, __v_14]; if unconstrained { __scratch.push(Bytes2::add(&__v_15, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) }; let __v_17: G = __b2_add.0; let __v_18: G = __b2_add.1; let __v_19: G = (__v_16 + __v_18); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; let __v_20: G = __b2_add.0; let __v_21: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_20, &__v_19); let mut __scratch: Vec = vec![__v_20, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_20, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) }; let __v_22: G = __b2_add.0; let __v_23: G = __b2_add.1; let __ret: [G; OUT_12] = [__v_22, __v_17, __v_12, __v_8]; @@ -2347,9 +2334,9 @@ fn aiur_fn_15( let __v_2: G = __io_pair.0; let __v_3: G = __io_pair.1; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -2406,9 +2393,9 @@ fn aiur_fn_16( let __v_4: G = __io_pair.0; let __v_5: G = __io_pair.1; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -2449,7 +2436,7 @@ fn aiur_fn_16( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = result.output.try_into().unwrap(); __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_16] = [__v_40]; record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -2520,7 +2507,7 @@ fn aiur_fn_17( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; @@ -2557,7 +2544,7 @@ fn aiur_fn_17( let __v_83: G = __loaded[31]; let __v_84: G = __loaded[32]; let __v_85: G = __loaded[33]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = __r_arr[2]; @@ -2607,7 +2594,7 @@ fn aiur_fn_18( ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -2689,7 +2676,7 @@ fn aiur_fn_19( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = result.output.try_into().unwrap(); __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -2835,7 +2822,7 @@ fn aiur_fn_20( ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = result.output.try_into().unwrap(); __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -2998,7 +2985,7 @@ fn aiur_fn_21( let __v_99: G = __loaded[32]; let __v_100: G = __loaded[33]; let __v_101: G = G::from_u64(0); - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_101]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = result.output.try_into().unwrap(); __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = __r_arr[2]; @@ -3121,7 +3108,7 @@ fn aiur_fn_21( let __v_211: G = G::from_u64(0); let __v_212: G = G::from_u64(0); let __v_213: G = G::from_u64(64); - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_214: G = __r_arr[0]; let __v_215: G = __r_arr[1]; let __v_216: G = __r_arr[2]; @@ -3172,7 +3159,7 @@ fn aiur_fn_21( let __v_209: G = G::from_u64(0); let __v_210: G = G::from_u64(0); let __v_211: G = G::from_u64(64); - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __v_213: G = __r_arr[1]; let __v_214: G = __r_arr[2]; @@ -3351,7 +3338,7 @@ fn aiur_fn_22( let __v_100: G = __loaded[32]; let __v_101: G = __loaded[33]; let __v_102: G = G::from_u64(1); - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_102]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = result.output.try_into().unwrap(); __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = __r_arr[2]; @@ -3421,7 +3408,7 @@ fn aiur_fn_22( let __v_169: G = __r_arr[66]; match __v_103.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_170: G = __r_arr[0]; let __v_171: G = __r_arr[1]; let __v_172: G = __r_arr[2]; @@ -3461,7 +3448,7 @@ fn aiur_fn_22( 1u64 => { let __v_170: G = G::from_u64(0); let __v_171: G = { let __values: [G; 34] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_170, __v_171, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = result.output.try_into().unwrap(); __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_170, __v_171, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; @@ -3535,7 +3522,7 @@ fn aiur_fn_23( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = result.output.try_into().unwrap(); __ret } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_23] = [__v_10]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -3546,7 +3533,7 @@ fn aiur_fn_23( let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = result.output.try_into().unwrap(); __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_23] = [__v_12]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -3557,7 +3544,7 @@ fn aiur_fn_23( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_23] = [__v_16]; record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -4317,7 +4304,7 @@ fn aiur_fn_25( let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = result.output.try_into().unwrap(); __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_7]; record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -4485,7 +4472,7 @@ fn aiur_fn_26( let __v_122: G = __loaded[6]; let __v_123: G = __loaded[7]; let __v_124: G = G::from_u64(0); - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = __r_arr[1]; let __v_127: G = __r_arr[2]; @@ -4631,7 +4618,7 @@ fn aiur_fn_26( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4641,9 +4628,9 @@ fn aiur_fn_26( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = result.output.try_into().unwrap(); __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = result.output.try_into().unwrap(); __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -4751,7 +4738,7 @@ fn aiur_fn_26( let __v_129: G = __loaded[5]; let __v_130: G = __loaded[6]; let __v_131: G = __loaded[7]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_132: G = __r_arr[0]; let __v_133: G = __r_arr[1]; let __v_134: G = __r_arr[2]; @@ -4812,7 +4799,7 @@ fn aiur_fn_27( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = result.output.try_into().unwrap(); __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -4879,7 +4866,7 @@ fn aiur_fn_27( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -4890,7 +4877,7 @@ fn aiur_fn_27( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -4971,7 +4958,7 @@ fn aiur_fn_27( let __v_157: G = __loaded[6]; let __v_158: G = __loaded[7]; let __v_159: G = G::from_u64(64); - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __v_162: G = __r_arr[2]; @@ -5019,7 +5006,7 @@ fn aiur_fn_27( let __v_203: G = __loaded[5]; let __v_204: G = __loaded[6]; let __v_205: G = __loaded[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_206: G = __r_arr[0]; let __v_207: G = __r_arr[1]; let __v_208: G = __r_arr[2]; @@ -5030,17 +5017,17 @@ fn aiur_fn_27( let __v_213: G = __r_arr[7]; let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_216]; record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = result.output.try_into().unwrap(); __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -5051,7 +5038,7 @@ fn aiur_fn_27( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -5104,7 +5091,7 @@ fn aiur_fn_27( let __v_131: G = __loaded[6]; let __v_132: G = __loaded[7]; let __v_133: G = G::from_u64(64); - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = result.output.try_into().unwrap(); __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; let __v_134: G = __r_arr[0]; let __v_135: G = __r_arr[1]; let __v_136: G = __r_arr[2]; @@ -5144,7 +5131,7 @@ fn aiur_fn_27( let __v_170: G = G::from_u64(1); let __v_171: G = (__v_2 + __v_170); let __v_172: G = { let __values: [G; 32] = [__v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = result.output.try_into().unwrap(); __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_173]; record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -5188,194 +5175,178 @@ fn aiur_fn_28( let __v_21: G = inp[21]; let __v_22: G = inp[22]; let __v_23: G = inp[23]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_0, &__v_4); let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.push(Bytes2::add(&__v_0, &__v_4).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; let __v_24: G = __b2_add.0; let __v_25: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_1, &__v_5); let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.push(Bytes2::add(&__v_1, &__v_5).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; let __v_26: G = __b2_add.0; let __v_27: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_26, &__v_25); let mut __scratch: Vec = vec![__v_26, __v_25]; if unconstrained { __scratch.push(Bytes2::add(&__v_26, &__v_25).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_26, &__v_25) } else { bytes2_add_value(__v_26, __v_25, record) }; let __v_28: G = __b2_add.0; let __v_29: G = __b2_add.1; let __v_30: G = (__v_27 + __v_29); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_2, &__v_6); let mut __scratch: Vec = vec![__v_2, __v_6]; if unconstrained { __scratch.push(Bytes2::add(&__v_2, &__v_6).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; let __v_31: G = __b2_add.0; let __v_32: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_31, &__v_30); let mut __scratch: Vec = vec![__v_31, __v_30]; if unconstrained { __scratch.push(Bytes2::add(&__v_31, &__v_30).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_31, &__v_30) } else { bytes2_add_value(__v_31, __v_30, record) }; let __v_33: G = __b2_add.0; let __v_34: G = __b2_add.1; let __v_35: G = (__v_32 + __v_34); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_3, &__v_7); let mut __scratch: Vec = vec![__v_3, __v_7]; if unconstrained { __scratch.push(Bytes2::add(&__v_3, &__v_7).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; let __v_36: G = __b2_add.0; let __v_37: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_36, &__v_35); let mut __scratch: Vec = vec![__v_36, __v_35]; if unconstrained { __scratch.push(Bytes2::add(&__v_36, &__v_35).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_36, &__v_35) } else { bytes2_add_value(__v_36, __v_35, record) }; let __v_38: G = __b2_add.0; let __v_39: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_24, &__v_16); let mut __scratch: Vec = vec![__v_24, __v_16]; if unconstrained { __scratch.push(Bytes2::add(&__v_24, &__v_16).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_24, &__v_16) } else { bytes2_add_value(__v_24, __v_16, record) }; let __v_40: G = __b2_add.0; let __v_41: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_28, &__v_17); let mut __scratch: Vec = vec![__v_28, __v_17]; if unconstrained { __scratch.push(Bytes2::add(&__v_28, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_17) } else { bytes2_add_value(__v_28, __v_17, record) }; let __v_42: G = __b2_add.0; let __v_43: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_42, &__v_41); let mut __scratch: Vec = vec![__v_42, __v_41]; if unconstrained { __scratch.push(Bytes2::add(&__v_42, &__v_41).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_42, &__v_41) } else { bytes2_add_value(__v_42, __v_41, record) }; let __v_44: G = __b2_add.0; let __v_45: G = __b2_add.1; let __v_46: G = (__v_43 + __v_45); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_33, &__v_18); let mut __scratch: Vec = vec![__v_33, __v_18]; if unconstrained { __scratch.push(Bytes2::add(&__v_33, &__v_18).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_18) } else { bytes2_add_value(__v_33, __v_18, record) }; let __v_47: G = __b2_add.0; let __v_48: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_47, &__v_46); let mut __scratch: Vec = vec![__v_47, __v_46]; if unconstrained { __scratch.push(Bytes2::add(&__v_47, &__v_46).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_47, &__v_46) } else { bytes2_add_value(__v_47, __v_46, record) }; let __v_49: G = __b2_add.0; let __v_50: G = __b2_add.1; let __v_51: G = (__v_48 + __v_50); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_38, &__v_19); let mut __scratch: Vec = vec![__v_38, __v_19]; if unconstrained { __scratch.push(Bytes2::add(&__v_38, &__v_19).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_19) } else { bytes2_add_value(__v_38, __v_19, record) }; let __v_52: G = __b2_add.0; let __v_53: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_52, &__v_51); let mut __scratch: Vec = vec![__v_52, __v_51]; if unconstrained { __scratch.push(Bytes2::add(&__v_52, &__v_51).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_52, &__v_51) } else { bytes2_add_value(__v_52, __v_51, record) }; let __v_54: G = __b2_add.0; let __v_55: G = __b2_add.1; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_12, __v_40]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_12, &__v_40)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_56: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_13, __v_44]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_13, &__v_44)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_57: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_14, __v_49]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_14, &__v_49)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_58: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_15, __v_54]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_15, &__v_54)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_59: G = __b2_out[0]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_8, &__v_58); let mut __scratch: Vec = vec![__v_8, __v_58]; if unconstrained { __scratch.push(Bytes2::add(&__v_8, &__v_58).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_56: G = if unconstrained { Bytes2::xor(&__v_12, &__v_40) } else { bytes2_xor_value(__v_12, __v_40, record) }; + let __v_57: G = if unconstrained { Bytes2::xor(&__v_13, &__v_44) } else { bytes2_xor_value(__v_13, __v_44, record) }; + let __v_58: G = if unconstrained { Bytes2::xor(&__v_14, &__v_49) } else { bytes2_xor_value(__v_14, __v_49, record) }; + let __v_59: G = if unconstrained { Bytes2::xor(&__v_15, &__v_54) } else { bytes2_xor_value(__v_15, __v_54, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_8, &__v_58) } else { bytes2_add_value(__v_8, __v_58, record) }; let __v_60: G = __b2_add.0; let __v_61: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_9, &__v_59); let mut __scratch: Vec = vec![__v_9, __v_59]; if unconstrained { __scratch.push(Bytes2::add(&__v_9, &__v_59).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_9, &__v_59) } else { bytes2_add_value(__v_9, __v_59, record) }; let __v_62: G = __b2_add.0; let __v_63: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_62, &__v_61); let mut __scratch: Vec = vec![__v_62, __v_61]; if unconstrained { __scratch.push(Bytes2::add(&__v_62, &__v_61).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_62, &__v_61) } else { bytes2_add_value(__v_62, __v_61, record) }; let __v_64: G = __b2_add.0; let __v_65: G = __b2_add.1; let __v_66: G = (__v_63 + __v_65); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_10, &__v_56); let mut __scratch: Vec = vec![__v_10, __v_56]; if unconstrained { __scratch.push(Bytes2::add(&__v_10, &__v_56).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_56) } else { bytes2_add_value(__v_10, __v_56, record) }; let __v_67: G = __b2_add.0; let __v_68: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_67, &__v_66); let mut __scratch: Vec = vec![__v_67, __v_66]; if unconstrained { __scratch.push(Bytes2::add(&__v_67, &__v_66).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_67, &__v_66) } else { bytes2_add_value(__v_67, __v_66, record) }; let __v_69: G = __b2_add.0; let __v_70: G = __b2_add.1; let __v_71: G = (__v_68 + __v_70); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_11, &__v_57); let mut __scratch: Vec = vec![__v_11, __v_57]; if unconstrained { __scratch.push(Bytes2::add(&__v_11, &__v_57).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_11, &__v_57) } else { bytes2_add_value(__v_11, __v_57, record) }; let __v_72: G = __b2_add.0; let __v_73: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_72, &__v_71); let mut __scratch: Vec = vec![__v_72, __v_71]; if unconstrained { __scratch.push(Bytes2::add(&__v_72, &__v_71).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_72, &__v_71) } else { bytes2_add_value(__v_72, __v_71, record) }; let __v_74: G = __b2_add.0; let __v_75: G = __b2_add.1; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_60]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_60)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_76: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_64]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_5, &__v_64)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_77: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_69]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_6, &__v_69)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_78: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_74]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_7, &__v_74)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_79: G = __b2_out[0]; - let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_77, __v_78]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr4(&__v_77, &__v_78).0, Bytes2::chain_rotr4(&__v_77, &__v_78).1, Bytes2::chain_rotr4(&__v_77, &__v_78).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr4, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_80: G = __b2_out[0]; - let __v_81: G = __b2_out[1]; - let __v_82: G = __b2_out[2]; - let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_79, __v_76]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr4(&__v_79, &__v_76).0, Bytes2::chain_rotr4(&__v_79, &__v_76).1, Bytes2::chain_rotr4(&__v_79, &__v_76).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr4, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_83: G = __b2_out[0]; - let __v_84: G = __b2_out[1]; - let __v_85: G = __b2_out[2]; + let __v_76: G = if unconstrained { Bytes2::xor(&__v_4, &__v_60) } else { bytes2_xor_value(__v_4, __v_60, record) }; + let __v_77: G = if unconstrained { Bytes2::xor(&__v_5, &__v_64) } else { bytes2_xor_value(__v_5, __v_64, record) }; + let __v_78: G = if unconstrained { Bytes2::xor(&__v_6, &__v_69) } else { bytes2_xor_value(__v_6, __v_69, record) }; + let __v_79: G = if unconstrained { Bytes2::xor(&__v_7, &__v_74) } else { bytes2_xor_value(__v_7, __v_74, record) }; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_77, &__v_78) } else { bytes2_chain_rotr4_value(__v_77, __v_78, record) }; + let __v_80: G = __b2_out.0; + let __v_81: G = __b2_out.1; + let __v_82: G = __b2_out.2; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_79, &__v_76) } else { bytes2_chain_rotr4_value(__v_79, __v_76, record) }; + let __v_83: G = __b2_out.0; + let __v_84: G = __b2_out.1; + let __v_85: G = __b2_out.2; let __v_86: G = (__v_81 + __v_85); let __v_87: G = (__v_84 + __v_82); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_40, &__v_80); let mut __scratch: Vec = vec![__v_40, __v_80]; if unconstrained { __scratch.push(Bytes2::add(&__v_40, &__v_80).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_40, &__v_80) } else { bytes2_add_value(__v_40, __v_80, record) }; let __v_88: G = __b2_add.0; let __v_89: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_44, &__v_86); let mut __scratch: Vec = vec![__v_44, __v_86]; if unconstrained { __scratch.push(Bytes2::add(&__v_44, &__v_86).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_44, &__v_86) } else { bytes2_add_value(__v_44, __v_86, record) }; let __v_90: G = __b2_add.0; let __v_91: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_90, &__v_89); let mut __scratch: Vec = vec![__v_90, __v_89]; if unconstrained { __scratch.push(Bytes2::add(&__v_90, &__v_89).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_90, &__v_89) } else { bytes2_add_value(__v_90, __v_89, record) }; let __v_92: G = __b2_add.0; let __v_93: G = __b2_add.1; let __v_94: G = (__v_91 + __v_93); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_49, &__v_83); let mut __scratch: Vec = vec![__v_49, __v_83]; if unconstrained { __scratch.push(Bytes2::add(&__v_49, &__v_83).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_49, &__v_83) } else { bytes2_add_value(__v_49, __v_83, record) }; let __v_95: G = __b2_add.0; let __v_96: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_95, &__v_94); let mut __scratch: Vec = vec![__v_95, __v_94]; if unconstrained { __scratch.push(Bytes2::add(&__v_95, &__v_94).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_95, &__v_94) } else { bytes2_add_value(__v_95, __v_94, record) }; let __v_97: G = __b2_add.0; let __v_98: G = __b2_add.1; let __v_99: G = (__v_96 + __v_98); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_54, &__v_87); let mut __scratch: Vec = vec![__v_54, __v_87]; if unconstrained { __scratch.push(Bytes2::add(&__v_54, &__v_87).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_54, &__v_87) } else { bytes2_add_value(__v_54, __v_87, record) }; let __v_100: G = __b2_add.0; let __v_101: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_100, &__v_99); let mut __scratch: Vec = vec![__v_100, __v_99]; if unconstrained { __scratch.push(Bytes2::add(&__v_100, &__v_99).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_100, &__v_99) } else { bytes2_add_value(__v_100, __v_99, record) }; let __v_102: G = __b2_add.0; let __v_103: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_88, &__v_20); let mut __scratch: Vec = vec![__v_88, __v_20]; if unconstrained { __scratch.push(Bytes2::add(&__v_88, &__v_20).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_88, &__v_20) } else { bytes2_add_value(__v_88, __v_20, record) }; let __v_104: G = __b2_add.0; let __v_105: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_92, &__v_21); let mut __scratch: Vec = vec![__v_92, __v_21]; if unconstrained { __scratch.push(Bytes2::add(&__v_92, &__v_21).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_92, &__v_21) } else { bytes2_add_value(__v_92, __v_21, record) }; let __v_106: G = __b2_add.0; let __v_107: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_106, &__v_105); let mut __scratch: Vec = vec![__v_106, __v_105]; if unconstrained { __scratch.push(Bytes2::add(&__v_106, &__v_105).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_106, &__v_105) } else { bytes2_add_value(__v_106, __v_105, record) }; let __v_108: G = __b2_add.0; let __v_109: G = __b2_add.1; let __v_110: G = (__v_107 + __v_109); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_97, &__v_22); let mut __scratch: Vec = vec![__v_97, __v_22]; if unconstrained { __scratch.push(Bytes2::add(&__v_97, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_97, &__v_22) } else { bytes2_add_value(__v_97, __v_22, record) }; let __v_111: G = __b2_add.0; let __v_112: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_111, &__v_110); let mut __scratch: Vec = vec![__v_111, __v_110]; if unconstrained { __scratch.push(Bytes2::add(&__v_111, &__v_110).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_111, &__v_110) } else { bytes2_add_value(__v_111, __v_110, record) }; let __v_113: G = __b2_add.0; let __v_114: G = __b2_add.1; let __v_115: G = (__v_112 + __v_114); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_102, &__v_23); let mut __scratch: Vec = vec![__v_102, __v_23]; if unconstrained { __scratch.push(Bytes2::add(&__v_102, &__v_23).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_102, &__v_23) } else { bytes2_add_value(__v_102, __v_23, record) }; let __v_116: G = __b2_add.0; let __v_117: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_116, &__v_115); let mut __scratch: Vec = vec![__v_116, __v_115]; if unconstrained { __scratch.push(Bytes2::add(&__v_116, &__v_115).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_116, &__v_115) } else { bytes2_add_value(__v_116, __v_115, record) }; let __v_118: G = __b2_add.0; let __v_119: G = __b2_add.1; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_58, __v_104]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_58, &__v_104)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_120: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_59, __v_108]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_59, &__v_108)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_121: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_56, __v_113]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_56, &__v_113)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_122: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_57, __v_118]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_57, &__v_118)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_123: G = __b2_out[0]; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_60, &__v_121); let mut __scratch: Vec = vec![__v_60, __v_121]; if unconstrained { __scratch.push(Bytes2::add(&__v_60, &__v_121).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __v_120: G = if unconstrained { Bytes2::xor(&__v_58, &__v_104) } else { bytes2_xor_value(__v_58, __v_104, record) }; + let __v_121: G = if unconstrained { Bytes2::xor(&__v_59, &__v_108) } else { bytes2_xor_value(__v_59, __v_108, record) }; + let __v_122: G = if unconstrained { Bytes2::xor(&__v_56, &__v_113) } else { bytes2_xor_value(__v_56, __v_113, record) }; + let __v_123: G = if unconstrained { Bytes2::xor(&__v_57, &__v_118) } else { bytes2_xor_value(__v_57, __v_118, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_60, &__v_121) } else { bytes2_add_value(__v_60, __v_121, record) }; let __v_124: G = __b2_add.0; let __v_125: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_64, &__v_122); let mut __scratch: Vec = vec![__v_64, __v_122]; if unconstrained { __scratch.push(Bytes2::add(&__v_64, &__v_122).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_64, &__v_122) } else { bytes2_add_value(__v_64, __v_122, record) }; let __v_126: G = __b2_add.0; let __v_127: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_126, &__v_125); let mut __scratch: Vec = vec![__v_126, __v_125]; if unconstrained { __scratch.push(Bytes2::add(&__v_126, &__v_125).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_126, &__v_125) } else { bytes2_add_value(__v_126, __v_125, record) }; let __v_128: G = __b2_add.0; let __v_129: G = __b2_add.1; let __v_130: G = (__v_127 + __v_129); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_69, &__v_123); let mut __scratch: Vec = vec![__v_69, __v_123]; if unconstrained { __scratch.push(Bytes2::add(&__v_69, &__v_123).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_69, &__v_123) } else { bytes2_add_value(__v_69, __v_123, record) }; let __v_131: G = __b2_add.0; let __v_132: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_131, &__v_130); let mut __scratch: Vec = vec![__v_131, __v_130]; if unconstrained { __scratch.push(Bytes2::add(&__v_131, &__v_130).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_131, &__v_130) } else { bytes2_add_value(__v_131, __v_130, record) }; let __v_133: G = __b2_add.0; let __v_134: G = __b2_add.1; let __v_135: G = (__v_132 + __v_134); - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_74, &__v_120); let mut __scratch: Vec = vec![__v_74, __v_120]; if unconstrained { __scratch.push(Bytes2::add(&__v_74, &__v_120).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_74, &__v_120) } else { bytes2_add_value(__v_74, __v_120, record) }; let __v_136: G = __b2_add.0; let __v_137: G = __b2_add.1; - let __b2_add: (G, G) = { let (_, __carry) = Bytes2::add(&__v_136, &__v_135); let mut __scratch: Vec = vec![__v_136, __v_135]; if unconstrained { __scratch.push(Bytes2::add(&__v_136, &__v_135).0); } else { bytes2_execute(0, 1, &Bytes2Op::Add, &mut __scratch, record); } (__scratch[2], __carry) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_136, &__v_135) } else { bytes2_add_value(__v_136, __v_135, record) }; let __v_138: G = __b2_add.0; let __v_139: G = __b2_add.1; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_80, __v_124]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_80, &__v_124)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_140: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_86, __v_128]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_86, &__v_128)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_141: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_83, __v_133]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_83, &__v_133)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_142: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_87, __v_138]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_87, &__v_138)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_143: G = __b2_out[0]; - let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_140, __v_141]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr7(&__v_140, &__v_141).0, Bytes2::chain_rotr7(&__v_140, &__v_141).1, Bytes2::chain_rotr7(&__v_140, &__v_141).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr7, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_144: G = __b2_out[0]; - let __v_145: G = __b2_out[1]; - let __v_146: G = __b2_out[2]; - let __b2_out: [G; 3] = { let mut __scratch: Vec = vec![__v_142, __v_143]; if unconstrained { __scratch.extend(vec![Bytes2::chain_rotr7(&__v_142, &__v_143).0, Bytes2::chain_rotr7(&__v_142, &__v_143).1, Bytes2::chain_rotr7(&__v_142, &__v_143).2]); } else { bytes2_execute(0, 1, &Bytes2Op::ChainRotr7, &mut __scratch, record); } let __arr: [G; 3] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_147: G = __b2_out[0]; - let __v_148: G = __b2_out[1]; - let __v_149: G = __b2_out[2]; + let __v_140: G = if unconstrained { Bytes2::xor(&__v_80, &__v_124) } else { bytes2_xor_value(__v_80, __v_124, record) }; + let __v_141: G = if unconstrained { Bytes2::xor(&__v_86, &__v_128) } else { bytes2_xor_value(__v_86, __v_128, record) }; + let __v_142: G = if unconstrained { Bytes2::xor(&__v_83, &__v_133) } else { bytes2_xor_value(__v_83, __v_133, record) }; + let __v_143: G = if unconstrained { Bytes2::xor(&__v_87, &__v_138) } else { bytes2_xor_value(__v_87, __v_138, record) }; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_140, &__v_141) } else { bytes2_chain_rotr7_value(__v_140, __v_141, record) }; + let __v_144: G = __b2_out.0; + let __v_145: G = __b2_out.1; + let __v_146: G = __b2_out.2; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_142, &__v_143) } else { bytes2_chain_rotr7_value(__v_142, __v_143, record) }; + let __v_147: G = __b2_out.0; + let __v_148: G = __b2_out.1; + let __v_149: G = __b2_out.2; let __v_150: G = (__v_145 + __v_149); let __v_151: G = (__v_148 + __v_146); let __ret: [G; OUT_28] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; @@ -5522,7 +5493,7 @@ fn aiur_fn_29( let __v_125: G = inp[125]; let __v_126: G = inp[126]; let __v_127: G = inp[127]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_128: G = __r_arr[0]; let __v_129: G = __r_arr[1]; let __v_130: G = __r_arr[2]; @@ -5539,7 +5510,7 @@ fn aiur_fn_29( let __v_141: G = __r_arr[13]; let __v_142: G = __r_arr[14]; let __v_143: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __v_146: G = __r_arr[2]; @@ -5556,7 +5527,7 @@ fn aiur_fn_29( let __v_157: G = __r_arr[13]; let __v_158: G = __r_arr[14]; let __v_159: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_160: G = __r_arr[0]; let __v_161: G = __r_arr[1]; let __v_162: G = __r_arr[2]; @@ -5573,7 +5544,7 @@ fn aiur_fn_29( let __v_173: G = __r_arr[13]; let __v_174: G = __r_arr[14]; let __v_175: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_176: G = __r_arr[0]; let __v_177: G = __r_arr[1]; let __v_178: G = __r_arr[2]; @@ -5590,7 +5561,7 @@ fn aiur_fn_29( let __v_189: G = __r_arr[13]; let __v_190: G = __r_arr[14]; let __v_191: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_192: G = __r_arr[0]; let __v_193: G = __r_arr[1]; let __v_194: G = __r_arr[2]; @@ -5607,7 +5578,7 @@ fn aiur_fn_29( let __v_205: G = __r_arr[13]; let __v_206: G = __r_arr[14]; let __v_207: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_208: G = __r_arr[0]; let __v_209: G = __r_arr[1]; let __v_210: G = __r_arr[2]; @@ -5624,7 +5595,7 @@ fn aiur_fn_29( let __v_221: G = __r_arr[13]; let __v_222: G = __r_arr[14]; let __v_223: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; @@ -5641,7 +5612,7 @@ fn aiur_fn_29( let __v_237: G = __r_arr[13]; let __v_238: G = __r_arr[14]; let __v_239: G = __r_arr[15]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = result.output.try_into().unwrap(); __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = __r_arr[2]; @@ -5802,7 +5773,7 @@ fn aiur_fn_30( let __v_125: G = G::from_u64(0); let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_128: G = __r_arr[0]; let __v_129: G = __r_arr[1]; let __v_130: G = __r_arr[2]; @@ -5931,7 +5902,7 @@ fn aiur_fn_30( let __v_253: G = __r_arr[125]; let __v_254: G = __r_arr[126]; let __v_255: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_256: G = __r_arr[0]; let __v_257: G = __r_arr[1]; let __v_258: G = __r_arr[2]; @@ -6060,7 +6031,7 @@ fn aiur_fn_30( let __v_381: G = __r_arr[125]; let __v_382: G = __r_arr[126]; let __v_383: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_384: G = __r_arr[0]; let __v_385: G = __r_arr[1]; let __v_386: G = __r_arr[2]; @@ -6189,7 +6160,7 @@ fn aiur_fn_30( let __v_509: G = __r_arr[125]; let __v_510: G = __r_arr[126]; let __v_511: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_512: G = __r_arr[0]; let __v_513: G = __r_arr[1]; let __v_514: G = __r_arr[2]; @@ -6318,7 +6289,7 @@ fn aiur_fn_30( let __v_637: G = __r_arr[125]; let __v_638: G = __r_arr[126]; let __v_639: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_640: G = __r_arr[0]; let __v_641: G = __r_arr[1]; let __v_642: G = __r_arr[2]; @@ -6447,7 +6418,7 @@ fn aiur_fn_30( let __v_765: G = __r_arr[125]; let __v_766: G = __r_arr[126]; let __v_767: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_768: G = __r_arr[0]; let __v_769: G = __r_arr[1]; let __v_770: G = __r_arr[2]; @@ -6576,7 +6547,7 @@ fn aiur_fn_30( let __v_893: G = __r_arr[125]; let __v_894: G = __r_arr[126]; let __v_895: G = __r_arr[127]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = result.output.try_into().unwrap(); __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; let __v_896: G = __r_arr[0]; let __v_897: G = __r_arr[1]; let __v_898: G = __r_arr[2]; @@ -6705,70 +6676,38 @@ fn aiur_fn_30( let __v_1021: G = __r_arr[125]; let __v_1022: G = __r_arr[126]; let __v_1023: G = __r_arr[127]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_896, __v_928]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_896, &__v_928)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1024: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_897, __v_929]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_897, &__v_929)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1025: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_898, __v_930]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_898, &__v_930)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1026: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_899, __v_931]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_899, &__v_931)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1027: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_900, __v_932]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_900, &__v_932)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1028: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_901, __v_933]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_901, &__v_933)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1029: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_902, __v_934]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_902, &__v_934)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1030: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_903, __v_935]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_903, &__v_935)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1031: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_904, __v_936]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_904, &__v_936)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1032: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_905, __v_937]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_905, &__v_937)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1033: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_906, __v_938]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_906, &__v_938)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1034: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_907, __v_939]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_907, &__v_939)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1035: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_908, __v_940]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_908, &__v_940)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1036: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_909, __v_941]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_909, &__v_941)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1037: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_910, __v_942]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_910, &__v_942)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1038: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_911, __v_943]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_911, &__v_943)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1039: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_912, __v_944]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_912, &__v_944)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1040: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_913, __v_945]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_913, &__v_945)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1041: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_914, __v_946]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_914, &__v_946)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1042: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_915, __v_947]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_915, &__v_947)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1043: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_916, __v_948]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_916, &__v_948)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1044: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_917, __v_949]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_917, &__v_949)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1045: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_918, __v_950]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_918, &__v_950)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1046: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_919, __v_951]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_919, &__v_951)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1047: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_920, __v_952]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_920, &__v_952)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1048: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_921, __v_953]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_921, &__v_953)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1049: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_922, __v_954]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_922, &__v_954)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1050: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_923, __v_955]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_923, &__v_955)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1051: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_924, __v_956]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_924, &__v_956)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1052: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_925, __v_957]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_925, &__v_957)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1053: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_926, __v_958]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_926, &__v_958)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1054: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_927, __v_959]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_927, &__v_959)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_1055: G = __b2_out[0]; + let __v_1024: G = if unconstrained { Bytes2::xor(&__v_896, &__v_928) } else { bytes2_xor_value(__v_896, __v_928, record) }; + let __v_1025: G = if unconstrained { Bytes2::xor(&__v_897, &__v_929) } else { bytes2_xor_value(__v_897, __v_929, record) }; + let __v_1026: G = if unconstrained { Bytes2::xor(&__v_898, &__v_930) } else { bytes2_xor_value(__v_898, __v_930, record) }; + let __v_1027: G = if unconstrained { Bytes2::xor(&__v_899, &__v_931) } else { bytes2_xor_value(__v_899, __v_931, record) }; + let __v_1028: G = if unconstrained { Bytes2::xor(&__v_900, &__v_932) } else { bytes2_xor_value(__v_900, __v_932, record) }; + let __v_1029: G = if unconstrained { Bytes2::xor(&__v_901, &__v_933) } else { bytes2_xor_value(__v_901, __v_933, record) }; + let __v_1030: G = if unconstrained { Bytes2::xor(&__v_902, &__v_934) } else { bytes2_xor_value(__v_902, __v_934, record) }; + let __v_1031: G = if unconstrained { Bytes2::xor(&__v_903, &__v_935) } else { bytes2_xor_value(__v_903, __v_935, record) }; + let __v_1032: G = if unconstrained { Bytes2::xor(&__v_904, &__v_936) } else { bytes2_xor_value(__v_904, __v_936, record) }; + let __v_1033: G = if unconstrained { Bytes2::xor(&__v_905, &__v_937) } else { bytes2_xor_value(__v_905, __v_937, record) }; + let __v_1034: G = if unconstrained { Bytes2::xor(&__v_906, &__v_938) } else { bytes2_xor_value(__v_906, __v_938, record) }; + let __v_1035: G = if unconstrained { Bytes2::xor(&__v_907, &__v_939) } else { bytes2_xor_value(__v_907, __v_939, record) }; + let __v_1036: G = if unconstrained { Bytes2::xor(&__v_908, &__v_940) } else { bytes2_xor_value(__v_908, __v_940, record) }; + let __v_1037: G = if unconstrained { Bytes2::xor(&__v_909, &__v_941) } else { bytes2_xor_value(__v_909, __v_941, record) }; + let __v_1038: G = if unconstrained { Bytes2::xor(&__v_910, &__v_942) } else { bytes2_xor_value(__v_910, __v_942, record) }; + let __v_1039: G = if unconstrained { Bytes2::xor(&__v_911, &__v_943) } else { bytes2_xor_value(__v_911, __v_943, record) }; + let __v_1040: G = if unconstrained { Bytes2::xor(&__v_912, &__v_944) } else { bytes2_xor_value(__v_912, __v_944, record) }; + let __v_1041: G = if unconstrained { Bytes2::xor(&__v_913, &__v_945) } else { bytes2_xor_value(__v_913, __v_945, record) }; + let __v_1042: G = if unconstrained { Bytes2::xor(&__v_914, &__v_946) } else { bytes2_xor_value(__v_914, __v_946, record) }; + let __v_1043: G = if unconstrained { Bytes2::xor(&__v_915, &__v_947) } else { bytes2_xor_value(__v_915, __v_947, record) }; + let __v_1044: G = if unconstrained { Bytes2::xor(&__v_916, &__v_948) } else { bytes2_xor_value(__v_916, __v_948, record) }; + let __v_1045: G = if unconstrained { Bytes2::xor(&__v_917, &__v_949) } else { bytes2_xor_value(__v_917, __v_949, record) }; + let __v_1046: G = if unconstrained { Bytes2::xor(&__v_918, &__v_950) } else { bytes2_xor_value(__v_918, __v_950, record) }; + let __v_1047: G = if unconstrained { Bytes2::xor(&__v_919, &__v_951) } else { bytes2_xor_value(__v_919, __v_951, record) }; + let __v_1048: G = if unconstrained { Bytes2::xor(&__v_920, &__v_952) } else { bytes2_xor_value(__v_920, __v_952, record) }; + let __v_1049: G = if unconstrained { Bytes2::xor(&__v_921, &__v_953) } else { bytes2_xor_value(__v_921, __v_953, record) }; + let __v_1050: G = if unconstrained { Bytes2::xor(&__v_922, &__v_954) } else { bytes2_xor_value(__v_922, __v_954, record) }; + let __v_1051: G = if unconstrained { Bytes2::xor(&__v_923, &__v_955) } else { bytes2_xor_value(__v_923, __v_955, record) }; + let __v_1052: G = if unconstrained { Bytes2::xor(&__v_924, &__v_956) } else { bytes2_xor_value(__v_924, __v_956, record) }; + let __v_1053: G = if unconstrained { Bytes2::xor(&__v_925, &__v_957) } else { bytes2_xor_value(__v_925, __v_957, record) }; + let __v_1054: G = if unconstrained { Bytes2::xor(&__v_926, &__v_958) } else { bytes2_xor_value(__v_926, __v_958, record) }; + let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; let __ret: [G; OUT_30] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -6789,7 +6728,7 @@ fn aiur_fn_31( let __v_1: G = G::from_u64(42); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -6797,13 +6736,13 @@ fn aiur_fn_31( let __v_8: G = __r_arr[4]; let __v_9: G = __r_arr[5]; let __v_10: G = G::from_u64(5); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(10); let __v_13: G = G::from_u64(100); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -6812,7 +6751,7 @@ fn aiur_fn_31( let __v_21: G = __r_arr[5]; let __v_22: G = G::from_u64(20); let __v_23: G = G::from_u64(200); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = __r_arr[2]; @@ -6821,7 +6760,7 @@ fn aiur_fn_31( let __v_29: G = __r_arr[5]; let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(50); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -6829,19 +6768,19 @@ fn aiur_fn_31( let __v_36: G = __r_arr[4]; let __v_37: G = __r_arr[5]; let __v_38: G = G::from_u64(5); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(10); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(20); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(10); let __v_45: G = G::from_u64(100); let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -6850,7 +6789,7 @@ fn aiur_fn_31( let __v_53: G = __r_arr[5]; let __v_54: G = G::from_u64(10); let __v_55: G = G::from_u64(999); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -6858,13 +6797,13 @@ fn aiur_fn_31( let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; let __v_62: G = G::from_u64(10); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(1); let __v_65: G = G::from_u64(10); let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -6873,7 +6812,7 @@ fn aiur_fn_31( let __v_73: G = __r_arr[5]; let __v_74: G = G::from_u64(2); let __v_75: G = G::from_u64(20); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = __r_arr[1]; let __v_78: G = __r_arr[2]; @@ -6882,7 +6821,7 @@ fn aiur_fn_31( let __v_81: G = __r_arr[5]; let __v_82: G = G::from_u64(3); let __v_83: G = G::from_u64(30); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -6891,7 +6830,7 @@ fn aiur_fn_31( let __v_89: G = __r_arr[5]; let __v_90: G = G::from_u64(4); let __v_91: G = G::from_u64(40); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = __r_arr[2]; @@ -6900,7 +6839,7 @@ fn aiur_fn_31( let __v_97: G = __r_arr[5]; let __v_98: G = G::from_u64(5); let __v_99: G = G::from_u64(50); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = __r_arr[1]; let __v_102: G = __r_arr[2]; @@ -6908,25 +6847,25 @@ fn aiur_fn_31( let __v_104: G = __r_arr[4]; let __v_105: G = __r_arr[5]; let __v_106: G = G::from_u64(1); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = G::from_u64(2); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; let __v_110: G = G::from_u64(3); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = G::from_u64(4); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = G::from_u64(5); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(5); let __v_117: G = G::from_u64(50); let __v_118: G = G::from_u64(1); let __v_119: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_120: G = __r_arr[0]; let __v_121: G = __r_arr[1]; let __v_122: G = __r_arr[2]; @@ -6935,7 +6874,7 @@ fn aiur_fn_31( let __v_125: G = __r_arr[5]; let __v_126: G = G::from_u64(4); let __v_127: G = G::from_u64(40); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_128: G = __r_arr[0]; let __v_129: G = __r_arr[1]; let __v_130: G = __r_arr[2]; @@ -6944,7 +6883,7 @@ fn aiur_fn_31( let __v_133: G = __r_arr[5]; let __v_134: G = G::from_u64(3); let __v_135: G = G::from_u64(30); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = __r_arr[1]; let __v_138: G = __r_arr[2]; @@ -6953,7 +6892,7 @@ fn aiur_fn_31( let __v_141: G = __r_arr[5]; let __v_142: G = G::from_u64(2); let __v_143: G = G::from_u64(20); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_144: G = __r_arr[0]; let __v_145: G = __r_arr[1]; let __v_146: G = __r_arr[2]; @@ -6962,7 +6901,7 @@ fn aiur_fn_31( let __v_149: G = __r_arr[5]; let __v_150: G = G::from_u64(1); let __v_151: G = G::from_u64(10); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __v_153: G = __r_arr[1]; let __v_154: G = __r_arr[2]; @@ -6970,25 +6909,25 @@ fn aiur_fn_31( let __v_156: G = __r_arr[4]; let __v_157: G = __r_arr[5]; let __v_158: G = G::from_u64(1); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_159: G = __r_arr[0]; let __v_160: G = G::from_u64(2); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_161: G = __r_arr[0]; let __v_162: G = G::from_u64(3); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_163: G = __r_arr[0]; let __v_164: G = G::from_u64(4); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; let __v_166: G = G::from_u64(5); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = G::from_u64(50); let __v_169: G = G::from_u64(500); let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; @@ -6997,7 +6936,7 @@ fn aiur_fn_31( let __v_177: G = __r_arr[5]; let __v_178: G = G::from_u64(30); let __v_179: G = G::from_u64(300); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_180: G = __r_arr[0]; let __v_181: G = __r_arr[1]; let __v_182: G = __r_arr[2]; @@ -7006,7 +6945,7 @@ fn aiur_fn_31( let __v_185: G = __r_arr[5]; let __v_186: G = G::from_u64(70); let __v_187: G = G::from_u64(700); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -7015,7 +6954,7 @@ fn aiur_fn_31( let __v_193: G = __r_arr[5]; let __v_194: G = G::from_u64(20); let __v_195: G = G::from_u64(200); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __v_197: G = __r_arr[1]; let __v_198: G = __r_arr[2]; @@ -7024,7 +6963,7 @@ fn aiur_fn_31( let __v_201: G = __r_arr[5]; let __v_202: G = G::from_u64(40); let __v_203: G = G::from_u64(400); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_204: G = __r_arr[0]; let __v_205: G = __r_arr[1]; let __v_206: G = __r_arr[2]; @@ -7033,7 +6972,7 @@ fn aiur_fn_31( let __v_209: G = __r_arr[5]; let __v_210: G = G::from_u64(60); let __v_211: G = G::from_u64(600); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; let __v_213: G = __r_arr[1]; let __v_214: G = __r_arr[2]; @@ -7042,7 +6981,7 @@ fn aiur_fn_31( let __v_217: G = __r_arr[5]; let __v_218: G = G::from_u64(80); let __v_219: G = G::from_u64(800); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_220: G = __r_arr[0]; let __v_221: G = __r_arr[1]; let __v_222: G = __r_arr[2]; @@ -7050,25 +6989,25 @@ fn aiur_fn_31( let __v_224: G = __r_arr[4]; let __v_225: G = __r_arr[5]; let __v_226: G = G::from_u64(20); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_227: G = __r_arr[0]; let __v_228: G = G::from_u64(30); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = G::from_u64(40); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = G::from_u64(50); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_233: G = __r_arr[0]; let __v_234: G = G::from_u64(60); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; let __v_236: G = G::from_u64(70); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_237: G = __r_arr[0]; let __v_238: G = G::from_u64(80); - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; let __ret: [G; OUT_31] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239]; record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7108,7 +7047,7 @@ fn aiur_fn_32( match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_20]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7116,14 +7055,14 @@ fn aiur_fn_32( }, 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_20]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7133,18 +7072,18 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_30]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7154,11 +7093,11 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(3); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_30]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7185,11 +7124,11 @@ fn aiur_fn_32( let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = G::from_u64(4); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_40]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7197,7 +7136,7 @@ fn aiur_fn_32( }, 5u64 => { let __v_19: G = G::from_u64(5); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_20]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7205,14 +7144,14 @@ fn aiur_fn_32( }, 6u64 => { let __v_19: G = G::from_u64(6); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_20]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = result.output.try_into().unwrap(); __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7222,16 +7161,16 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = result.output.try_into().unwrap(); __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_29]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = result.output.try_into().unwrap(); __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7241,16 +7180,16 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = result.output.try_into().unwrap(); __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_29]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = result.output.try_into().unwrap(); __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7260,9 +7199,9 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = result.output.try_into().unwrap(); __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_29]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7327,13 +7266,13 @@ fn aiur_fn_32( let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __v_73: G = G::from_u64(10); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_77]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7341,7 +7280,7 @@ fn aiur_fn_32( }, 11u64 => { let __v_19: G = G::from_u64(11); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_32] = [__v_20]; record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7385,7 +7324,7 @@ fn aiur_fn_33( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_8 - __v_12); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_33] = [__v_15]; @@ -7415,11 +7354,10 @@ fn aiur_fn_34( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(128); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_11: G = __b2_out[0]; + let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) }; match __v_9.as_canonical_u64() { 1u64 => { match __v_11.as_canonical_u64() { @@ -7436,7 +7374,7 @@ fn aiur_fn_34( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_34] = [__v_18]; @@ -7451,7 +7389,7 @@ fn aiur_fn_34( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_34] = [__v_18]; @@ -7482,11 +7420,10 @@ fn aiur_fn_35( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_1, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_12: G = __b2_out[0]; + let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { @@ -7509,7 +7446,7 @@ fn aiur_fn_35( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_35] = [__v_22]; @@ -7527,7 +7464,7 @@ fn aiur_fn_35( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_35] = [__v_22]; @@ -7558,11 +7495,10 @@ fn aiur_fn_36( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = result.output.try_into().unwrap(); __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_1, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_12: G = __b2_out[0]; + let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { @@ -7585,7 +7521,7 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_36] = [__v_22]; @@ -7603,7 +7539,7 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = result.output.try_into().unwrap(); __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_36] = [__v_22]; @@ -7644,9 +7580,9 @@ fn aiur_fn_37( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_11, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = result.output.try_into().unwrap(); __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_37] = [__v_13]; record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -7708,7 +7644,7 @@ fn aiur_fn_38( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = result.output.try_into().unwrap(); __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -7717,7 +7653,7 @@ fn aiur_fn_38( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -7796,7 +7732,7 @@ fn aiur_fn_39( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = result.output.try_into().unwrap(); __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -7805,7 +7741,7 @@ fn aiur_fn_39( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -7884,7 +7820,7 @@ fn aiur_fn_40( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = result.output.try_into().unwrap(); __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -7893,7 +7829,7 @@ fn aiur_fn_40( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -7992,16 +7928,16 @@ fn aiur_fn_41( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = result.output.try_into().unwrap(); __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_56]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_41] = [__v_19]; record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8080,16 +8016,16 @@ fn aiur_fn_42( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = result.output.try_into().unwrap(); __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_56]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_19]; record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8168,16 +8104,16 @@ fn aiur_fn_43( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = result.output.try_into().unwrap(); __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_43] = [__v_56]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_43] = [__v_19]; record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8428,7 +8364,7 @@ fn aiur_fn_46( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = result.output.try_into().unwrap(); __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -8437,7 +8373,7 @@ fn aiur_fn_46( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -8498,7 +8434,7 @@ fn aiur_fn_47( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = result.output.try_into().unwrap(); __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -8551,7 +8487,7 @@ fn aiur_fn_48( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = result.output.try_into().unwrap(); __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -8560,7 +8496,7 @@ fn aiur_fn_48( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = result.output.try_into().unwrap(); __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -8571,9 +8507,9 @@ fn aiur_fn_48( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_29]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8609,11 +8545,11 @@ fn aiur_fn_48( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_39]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8649,11 +8585,11 @@ fn aiur_fn_48( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_39]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8661,7 +8597,7 @@ fn aiur_fn_48( }, 4u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = result.output.try_into().unwrap(); __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_48] = [__v_11]; record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8716,9 +8652,9 @@ fn aiur_fn_49( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = result.output.try_into().unwrap(); __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_24]; record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8764,9 +8700,9 @@ fn aiur_fn_50( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = result.output.try_into().unwrap(); __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = result.output.try_into().unwrap(); __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_15]; record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8802,9 +8738,9 @@ fn aiur_fn_51( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = result.output.try_into().unwrap(); __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_6]; record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -8932,14 +8868,14 @@ fn aiur_fn_53( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = result.output.try_into().unwrap(); __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_53] = [__v_54]; @@ -8991,9 +8927,9 @@ fn aiur_fn_54( let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_54] = [__v_29]; record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9034,9 +8970,9 @@ fn aiur_fn_55( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_12, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = result.output.try_into().unwrap(); __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = result.output.try_into().unwrap(); __ret } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_14]; record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9128,7 +9064,7 @@ fn aiur_fn_56( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = result.output.try_into().unwrap(); __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9138,21 +9074,21 @@ fn aiur_fn_56( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = result.output.try_into().unwrap(); __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_56] = [__v_83]; @@ -9206,9 +9142,9 @@ fn aiur_fn_57( let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_57] = [__v_32]; @@ -9261,11 +9197,11 @@ fn aiur_fn_58( let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = result.output.try_into().unwrap(); __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_58] = [__v_31]; record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9342,15 +9278,15 @@ fn aiur_fn_59( let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_59] = [__v_59]; @@ -9417,9 +9353,9 @@ fn aiur_fn_60( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_37, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = result.output.try_into().unwrap(); __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = result.output.try_into().unwrap(); __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_60] = [__v_39]; record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9507,7 +9443,7 @@ fn aiur_fn_61( let __v_59: G = (__v_58 * __v_2); let __v_60: G = (__v_57 + __v_59); let __v_61: G = (__v_0 + __v_60); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = result.output.try_into().unwrap(); __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = __r_arr[2]; @@ -9517,19 +9453,19 @@ fn aiur_fn_61( let __v_68: G = __r_arr[6]; let __v_69: G = __r_arr[7]; let __v_70: G = G::from_u64(0); - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = result.output.try_into().unwrap(); __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_72]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = { let __values: [G; 3] = [__v_70, __v_61, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_61] = [__v_78]; @@ -9562,9 +9498,9 @@ fn aiur_fn_62( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_62] = [__v_11]; record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9604,11 +9540,11 @@ fn aiur_fn_63( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_20]; record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9678,7 +9614,7 @@ fn aiur_fn_64( 0u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = result.output.try_into().unwrap(); __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_64] = [__v_49]; @@ -9688,7 +9624,7 @@ fn aiur_fn_64( 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = result.output.try_into().unwrap(); __ret } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_64] = [__v_49]; @@ -9698,7 +9634,7 @@ fn aiur_fn_64( 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = result.output.try_into().unwrap(); __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_64] = [__v_49]; @@ -9779,9 +9715,9 @@ fn aiur_fn_65( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_48, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = result.output.try_into().unwrap(); __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = result.output.try_into().unwrap(); __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_50]; record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9852,56 +9788,56 @@ fn aiur_fn_66( let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = result.output.try_into().unwrap(); __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = result.output.try_into().unwrap(); __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = result.output.try_into().unwrap(); __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = result.output.try_into().unwrap(); __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = result.output.try_into().unwrap(); __ret } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = result.output.try_into().unwrap(); __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_46]; record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9926,7 +9862,7 @@ fn aiur_fn_67( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9935,9 +9871,9 @@ fn aiur_fn_67( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = result.output.try_into().unwrap(); __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_11]; record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9957,7 +9893,7 @@ fn aiur_fn_68( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9966,9 +9902,9 @@ fn aiur_fn_68( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = result.output.try_into().unwrap(); __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_11]; record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -9988,7 +9924,7 @@ fn aiur_fn_69( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -9997,9 +9933,9 @@ fn aiur_fn_69( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = result.output.try_into().unwrap(); __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = result.output.try_into().unwrap(); __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_11]; record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10068,15 +10004,15 @@ fn aiur_fn_70( let __v_48: G = inp[48]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = result.output.try_into().unwrap(); __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_46, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = result.output.try_into().unwrap(); __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_45, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = result.output.try_into().unwrap(); __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = result.output.try_into().unwrap(); __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -10086,9 +10022,9 @@ fn aiur_fn_70( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = result.output.try_into().unwrap(); __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10104,9 +10040,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10122,9 +10058,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10140,9 +10076,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10158,9 +10094,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10176,9 +10112,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10194,9 +10130,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10212,9 +10148,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10230,9 +10166,9 @@ fn aiur_fn_70( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = result.output.try_into().unwrap(); __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = result.output.try_into().unwrap(); __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_62]; record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -10311,12 +10247,12 @@ fn aiur_fn_72( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -10345,10 +10281,10 @@ fn aiur_fn_73( ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -10391,7 +10327,7 @@ fn aiur_fn_73( _ => { let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 + __v_29); - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -10420,10 +10356,10 @@ fn aiur_fn_74( ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -10463,7 +10399,7 @@ fn aiur_fn_74( _ => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_25 + __v_26); - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -10492,10 +10428,10 @@ fn aiur_fn_75( ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -10535,7 +10471,7 @@ fn aiur_fn_75( _ => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_25 + __v_26); - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = result.output.try_into().unwrap(); __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -10572,7 +10508,7 @@ fn aiur_fn_76( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -10584,7 +10520,7 @@ fn aiur_fn_76( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -10594,7 +10530,7 @@ fn aiur_fn_76( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -10603,7 +10539,7 @@ fn aiur_fn_76( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); @@ -10639,7 +10575,7 @@ fn aiur_fn_77( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -10667,7 +10603,7 @@ fn aiur_fn_77( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -10691,7 +10627,7 @@ fn aiur_fn_77( let __v_31: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 18] = [__v_30, __v_0, __v_31, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -10700,7 +10636,7 @@ fn aiur_fn_77( let __v_39: G = __r_arr[5]; let __v_40: G = __r_arr[6]; let __v_41: G = __r_arr[7]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_33, __v_29, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = result.output.try_into().unwrap(); __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_33, __v_29, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; @@ -10750,11 +10686,11 @@ fn aiur_fn_78( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -10779,7 +10715,7 @@ fn aiur_fn_78( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -10799,7 +10735,7 @@ fn aiur_fn_78( let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -10808,7 +10744,7 @@ fn aiur_fn_78( let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = result.output.try_into().unwrap(); __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -10862,11 +10798,11 @@ fn aiur_fn_79( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -10891,7 +10827,7 @@ fn aiur_fn_79( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -10911,7 +10847,7 @@ fn aiur_fn_79( let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -10920,7 +10856,7 @@ fn aiur_fn_79( let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = result.output.try_into().unwrap(); __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -10966,7 +10902,7 @@ fn aiur_fn_80( ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -10993,7 +10929,7 @@ fn aiur_fn_80( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11003,7 +10939,7 @@ fn aiur_fn_80( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); @@ -11013,7 +10949,7 @@ fn aiur_fn_80( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11023,7 +10959,7 @@ fn aiur_fn_80( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = result.output.try_into().unwrap(); __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); @@ -11033,7 +10969,7 @@ fn aiur_fn_80( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11043,7 +10979,7 @@ fn aiur_fn_80( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11084,7 +11020,7 @@ fn aiur_fn_80( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11105,7 +11041,7 @@ fn aiur_fn_80( let __v_28: G = __r_arr[17]; let __v_29: G = __r_arr[18]; let __v_30: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30, __v_29, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = result.output.try_into().unwrap(); __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_30, __v_29, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -11130,7 +11066,7 @@ fn aiur_fn_80( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = result.output.try_into().unwrap(); __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11155,7 +11091,7 @@ fn aiur_fn_80( return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = result.output.try_into().unwrap(); __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11180,7 +11116,7 @@ fn aiur_fn_80( return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = result.output.try_into().unwrap(); __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11237,7 +11173,7 @@ fn aiur_fn_81( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -11257,7 +11193,7 @@ fn aiur_fn_81( let __v_25: G = __r_arr[16]; let __v_26: G = __r_arr[17]; let __v_27: G = __r_arr[18]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -11277,7 +11213,7 @@ fn aiur_fn_81( let __v_44: G = __r_arr[16]; let __v_45: G = __r_arr[17]; let __v_46: G = __r_arr[18]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -11335,7 +11271,7 @@ fn aiur_fn_82( let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -11344,7 +11280,7 @@ fn aiur_fn_82( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -11353,7 +11289,7 @@ fn aiur_fn_82( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = result.output.try_into().unwrap(); __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -11388,7 +11324,7 @@ fn aiur_fn_83( ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = result.output.try_into().unwrap(); __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11401,7 +11337,7 @@ fn aiur_fn_83( let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -11412,7 +11348,7 @@ fn aiur_fn_83( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11423,7 +11359,7 @@ fn aiur_fn_83( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = result.output.try_into().unwrap(); __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -11443,7 +11379,7 @@ fn aiur_fn_83( } }, 1u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11454,7 +11390,7 @@ fn aiur_fn_83( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -11474,7 +11410,7 @@ fn aiur_fn_83( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11485,7 +11421,7 @@ fn aiur_fn_83( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -11528,100 +11464,100 @@ fn aiur_fn_84( ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -11650,7 +11586,7 @@ fn aiur_fn_85( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -11662,7 +11598,7 @@ fn aiur_fn_85( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -11682,7 +11618,7 @@ fn aiur_fn_85( let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; let __v_28: G = __r_arr[18]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11691,7 +11627,7 @@ fn aiur_fn_85( let __v_34: G = __r_arr[5]; let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = result.output.try_into().unwrap(); __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = G::from_u64(0); @@ -11727,7 +11663,7 @@ fn aiur_fn_86( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -11739,7 +11675,7 @@ fn aiur_fn_86( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = result.output.try_into().unwrap(); __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -11750,7 +11686,7 @@ fn aiur_fn_86( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11759,7 +11695,7 @@ fn aiur_fn_86( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = result.output.try_into().unwrap(); __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); @@ -11795,7 +11731,7 @@ fn aiur_fn_87( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -11807,10 +11743,10 @@ fn aiur_fn_87( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11819,7 +11755,7 @@ fn aiur_fn_87( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = result.output.try_into().unwrap(); __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); @@ -11846,7 +11782,7 @@ fn aiur_fn_88( ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11856,7 +11792,7 @@ fn aiur_fn_88( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = result.output.try_into().unwrap(); __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_88] = [__v_10, __v_11]; @@ -11876,7 +11812,7 @@ fn aiur_fn_89( ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11886,7 +11822,7 @@ fn aiur_fn_89( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = result.output.try_into().unwrap(); __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_10, __v_11]; @@ -11906,7 +11842,7 @@ fn aiur_fn_90( ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11916,7 +11852,7 @@ fn aiur_fn_90( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = result.output.try_into().unwrap(); __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_10, __v_11]; @@ -12018,13 +11954,13 @@ fn aiur_fn_92( ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = result.output.try_into().unwrap(); __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -12034,7 +11970,7 @@ fn aiur_fn_92( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -12054,7 +11990,7 @@ fn aiur_fn_92( let __v_30: G = __r_arr[16]; let __v_31: G = __r_arr[17]; let __v_32: G = __r_arr[18]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -12093,7 +12029,7 @@ fn aiur_fn_93( ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12103,7 +12039,7 @@ fn aiur_fn_93( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12149,7 +12085,7 @@ fn aiur_fn_94( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -12161,7 +12097,7 @@ fn aiur_fn_94( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = result.output.try_into().unwrap(); __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12172,7 +12108,7 @@ fn aiur_fn_94( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12181,7 +12117,7 @@ fn aiur_fn_94( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = result.output.try_into().unwrap(); __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); @@ -12208,10 +12144,10 @@ fn aiur_fn_95( ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -12220,7 +12156,7 @@ fn aiur_fn_95( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12230,7 +12166,7 @@ fn aiur_fn_95( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12240,7 +12176,7 @@ fn aiur_fn_95( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -12250,7 +12186,7 @@ fn aiur_fn_95( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -12260,7 +12196,7 @@ fn aiur_fn_95( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -12270,7 +12206,7 @@ fn aiur_fn_95( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -12290,7 +12226,7 @@ fn aiur_fn_95( let __v_72: G = __r_arr[16]; let __v_73: G = __r_arr[17]; let __v_74: G = __r_arr[18]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; @@ -12300,7 +12236,7 @@ fn aiur_fn_95( let __v_81: G = __r_arr[6]; let __v_82: G = __r_arr[7]; let __v_83: G = __r_arr[8]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_83, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = result.output.try_into().unwrap(); __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_83, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = { let __values: [G; 18] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -12321,10 +12257,10 @@ fn aiur_fn_96( ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -12334,7 +12270,7 @@ fn aiur_fn_96( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12415,12 +12351,12 @@ fn aiur_fn_98( ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -12430,7 +12366,7 @@ fn aiur_fn_98( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -12468,10 +12404,10 @@ fn aiur_fn_99( ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -12481,7 +12417,7 @@ fn aiur_fn_99( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12491,7 +12427,7 @@ fn aiur_fn_99( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12501,7 +12437,7 @@ fn aiur_fn_99( let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; @@ -12511,7 +12447,7 @@ fn aiur_fn_99( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -12557,7 +12493,7 @@ fn aiur_fn_100( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -12569,7 +12505,7 @@ fn aiur_fn_100( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = result.output.try_into().unwrap(); __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12605,7 +12541,7 @@ fn aiur_fn_100( let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -12614,7 +12550,7 @@ fn aiur_fn_100( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = result.output.try_into().unwrap(); __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); @@ -12641,10 +12577,10 @@ fn aiur_fn_101( ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -12653,7 +12589,7 @@ fn aiur_fn_101( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12663,7 +12599,7 @@ fn aiur_fn_101( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12673,7 +12609,7 @@ fn aiur_fn_101( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -12683,7 +12619,7 @@ fn aiur_fn_101( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -12693,7 +12629,7 @@ fn aiur_fn_101( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = result.output.try_into().unwrap(); __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -12713,7 +12649,7 @@ fn aiur_fn_101( let __v_63: G = __r_arr[16]; let __v_64: G = __r_arr[17]; let __v_65: G = __r_arr[18]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -12723,7 +12659,7 @@ fn aiur_fn_101( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = __r_arr[8]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_74, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = result.output.try_into().unwrap(); __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_74, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -12744,7 +12680,7 @@ fn aiur_fn_102( ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12754,7 +12690,7 @@ fn aiur_fn_102( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_102] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; @@ -12774,7 +12710,7 @@ fn aiur_fn_103( ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12784,7 +12720,7 @@ fn aiur_fn_103( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12794,7 +12730,7 @@ fn aiur_fn_103( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_103] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; @@ -12814,12 +12750,12 @@ fn aiur_fn_104( ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = result.output.try_into().unwrap(); __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -12840,7 +12776,7 @@ fn aiur_fn_104( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = result.output.try_into().unwrap(); __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -12886,7 +12822,7 @@ fn aiur_fn_104( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = result.output.try_into().unwrap(); __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -12963,7 +12899,7 @@ fn aiur_fn_105( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -12975,7 +12911,7 @@ fn aiur_fn_105( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = result.output.try_into().unwrap(); __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13022,7 +12958,7 @@ fn aiur_fn_105( let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -13031,7 +12967,7 @@ fn aiur_fn_105( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = result.output.try_into().unwrap(); __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); @@ -13061,7 +12997,7 @@ fn aiur_fn_106( let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = result.output.try_into().unwrap(); __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13082,7 +13018,7 @@ fn aiur_fn_106( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = result.output.try_into().unwrap(); __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13134,7 +13070,7 @@ fn aiur_fn_106( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = result.output.try_into().unwrap(); __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13153,7 +13089,7 @@ fn aiur_fn_106( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = result.output.try_into().unwrap(); __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13172,7 +13108,7 @@ fn aiur_fn_106( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = result.output.try_into().unwrap(); __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13198,7 +13134,7 @@ fn aiur_fn_106( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13216,7 +13152,7 @@ fn aiur_fn_106( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13234,7 +13170,7 @@ fn aiur_fn_106( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = result.output.try_into().unwrap(); __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13280,7 +13216,7 @@ fn aiur_fn_107( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = result.output.try_into().unwrap(); __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); @@ -13290,7 +13226,7 @@ fn aiur_fn_107( return Ok(__ret); }, 13u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = result.output.try_into().unwrap(); __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13359,7 +13295,7 @@ fn aiur_fn_108( ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13370,7 +13306,7 @@ fn aiur_fn_108( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = result.output.try_into().unwrap(); __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13417,13 +13353,13 @@ fn aiur_fn_108( let __v_54: G = __r_arr[43]; let __v_55: G = __r_arr[44]; let __v_56: G = __r_arr[45]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = result.output.try_into().unwrap(); __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = result.output.try_into().unwrap(); __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = result.output.try_into().unwrap(); __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __ret: [G; OUT_108] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_59, __v_61, __v_62]; @@ -13463,7 +13399,7 @@ fn aiur_fn_109( }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13475,12 +13411,12 @@ fn aiur_fn_109( }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -13491,12 +13427,12 @@ fn aiur_fn_109( }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -13507,7 +13443,7 @@ fn aiur_fn_109( }, 4u64 => { let __v_10: G = G::from_u64(4); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_10, __v_11, __v_12]; @@ -13554,17 +13490,17 @@ fn aiur_fn_110( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = { let __values: [G; 3] = [__v_14, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_110] = [__v_20]; @@ -13598,7 +13534,7 @@ fn aiur_fn_111( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13608,7 +13544,7 @@ fn aiur_fn_111( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = result.output.try_into().unwrap(); __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -13616,7 +13552,7 @@ fn aiur_fn_111( let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { @@ -13643,7 +13579,7 @@ fn aiur_fn_111( } }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = result.output.try_into().unwrap(); __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); let __v_25: G = { let __values: [G; 10] = [__v_24, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -13696,7 +13632,7 @@ fn aiur_fn_112( match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13711,7 +13647,7 @@ fn aiur_fn_112( }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13726,7 +13662,7 @@ fn aiur_fn_112( }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13741,7 +13677,7 @@ fn aiur_fn_112( }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13756,7 +13692,7 @@ fn aiur_fn_112( }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13771,7 +13707,7 @@ fn aiur_fn_112( }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13786,7 +13722,7 @@ fn aiur_fn_112( }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13801,7 +13737,7 @@ fn aiur_fn_112( }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = result.output.try_into().unwrap(); __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -13860,7 +13796,7 @@ fn aiur_fn_113( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = result.output.try_into().unwrap(); __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_7]; record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -13912,12 +13848,12 @@ fn aiur_fn_114( let __v_23: G = __loaded[17]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = result.output.try_into().unwrap(); __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -13930,7 +13866,7 @@ fn aiur_fn_114( }, 1u64 => { let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -13939,11 +13875,11 @@ fn aiur_fn_114( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __v_28: G = G::from_u64(0); @@ -13953,11 +13889,11 @@ fn aiur_fn_114( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = result.output.try_into().unwrap(); __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __v_28: G = G::from_u64(0); @@ -13967,14 +13903,14 @@ fn aiur_fn_114( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(8); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = { let __values: [G; 4] = [__v_26, __v_25, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_29]; @@ -13982,7 +13918,7 @@ fn aiur_fn_114( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(7); let __v_26: G = G::from_u64(1); @@ -13993,9 +13929,9 @@ fn aiur_fn_114( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = result.output.try_into().unwrap(); __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(0); @@ -14007,9 +13943,9 @@ fn aiur_fn_114( }, 7u64 => { let __v_24: G = G::from_u64(3); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -14019,9 +13955,9 @@ fn aiur_fn_114( }, 8u64 => { let __v_24: G = G::from_u64(4); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -14031,9 +13967,9 @@ fn aiur_fn_114( }, 9u64 => { let __v_24: G = G::from_u64(5); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -14043,11 +13979,11 @@ fn aiur_fn_114( }, 10u64 => { let __v_24: G = G::from_u64(6); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_114] = [__v_28]; @@ -14055,9 +13991,9 @@ fn aiur_fn_114( return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -14065,7 +14001,7 @@ fn aiur_fn_114( let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_29]; record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -14132,12 +14068,12 @@ fn aiur_fn_115( 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = result.output.try_into().unwrap(); __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __values: [G; 5] = [__v_23, __v_19, __v_22, __v_21, __v_24]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_115] = [__v_25]; @@ -14192,14 +14128,14 @@ fn aiur_fn_116( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_1, __v_17, __v_22, __v_22, __v_22, __v_22, __v_22]; @@ -14210,7 +14146,7 @@ fn aiur_fn_116( match __v_1.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(3); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(0); @@ -14220,7 +14156,7 @@ fn aiur_fn_116( }, _ => { let __v_20: G = G::from_u64(3); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); @@ -14232,7 +14168,7 @@ fn aiur_fn_116( }, 2u64 => { let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; @@ -14279,10 +14215,10 @@ fn aiur_fn_117( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_117] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; @@ -14324,10 +14260,10 @@ fn aiur_fn_118( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(4); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __ret: [G; OUT_118] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; @@ -14405,20 +14341,20 @@ fn aiur_fn_119( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = result.output.try_into().unwrap(); __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_53, __v_54, __v_51, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_50]; record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -14488,16 +14424,16 @@ fn aiur_fn_120( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_35, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_35, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(5); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_120] = [__v_45, __v_46, __v_44, __v_47, __v_48, __v_42, __v_0, __v_1, __v_2, __v_49, __v_43]; record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -14563,16 +14499,16 @@ fn aiur_fn_121( _ => { match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = result.output.try_into().unwrap(); __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __ret: [G; OUT_121] = [__v_41, __v_42, __v_40, __v_39, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; @@ -14653,7 +14589,7 @@ fn aiur_fn_122( _ => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = result.output.try_into().unwrap(); __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14670,7 +14606,7 @@ fn aiur_fn_122( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = result.output.try_into().unwrap(); __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14687,7 +14623,7 @@ fn aiur_fn_122( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = result.output.try_into().unwrap(); __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14704,7 +14640,7 @@ fn aiur_fn_122( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_1, __v_2, __v_3, __v_4, __v_5, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = result.output.try_into().unwrap(); __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_1, __v_2, __v_3, __v_4, __v_5, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14721,7 +14657,7 @@ fn aiur_fn_122( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_1, __v_2, __v_3, __v_4, __v_5, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = result.output.try_into().unwrap(); __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_1, __v_2, __v_3, __v_4, __v_5, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14738,7 +14674,7 @@ fn aiur_fn_122( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = result.output.try_into().unwrap(); __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = __r_arr[2]; @@ -14788,7 +14724,7 @@ fn aiur_fn_123( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = result.output.try_into().unwrap(); __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -14802,7 +14738,7 @@ fn aiur_fn_123( let __v_14: G = __r_arr[10]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 11] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_123] = [__v_18]; @@ -14865,9 +14801,9 @@ fn aiur_fn_124( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -14987,7 +14923,7 @@ fn aiur_fn_125( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(5); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_37]; record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15502,7 +15438,7 @@ fn aiur_fn_127( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = result.output.try_into().unwrap(); __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_67]; record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -15567,7 +15503,7 @@ fn aiur_fn_128( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(3); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -15951,7 +15887,7 @@ fn aiur_fn_131( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); let __v_47: G = (__v_45 + __v_46); @@ -16047,9 +15983,9 @@ fn aiur_fn_132( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = (__v_48 + __v_49); let __ret: [G; OUT_132] = [__v_50]; @@ -16133,11 +16069,11 @@ fn aiur_fn_133( let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_1 - __v_50); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_48, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_49 + __v_52); let __ret: [G; OUT_133] = [__v_53]; @@ -16175,11 +16111,11 @@ fn aiur_fn_134( let __v_8: G = __loaded[4]; let __v_9: G = __loaded[5]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_12]; record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16233,7 +16169,7 @@ fn aiur_fn_135( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -16242,7 +16178,7 @@ fn aiur_fn_135( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_135] = [__v_10]; record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16298,14 +16234,14 @@ fn aiur_fn_136( 0u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_6 + __v_8); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = result.output.try_into().unwrap(); __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __v_14: G = __r_arr[4]; let __v_15: G = __r_arr[5]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -16407,14 +16343,14 @@ fn aiur_fn_137( let __v_57: G = __loaded[47]; match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; let __v_61: G = __r_arr[3]; let __v_62: G = __r_arr[4]; let __v_63: G = __r_arr[5]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = result.output.try_into().unwrap(); __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -16463,20 +16399,20 @@ fn aiur_fn_138( }, 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = result.output.try_into().unwrap(); __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __v_16: G = __r_arr[3]; let __v_17: G = __r_arr[4]; let __v_18: G = __r_arr[5]; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -16488,7 +16424,7 @@ fn aiur_fn_138( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = result.output.try_into().unwrap(); __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -16522,7 +16458,7 @@ fn aiur_fn_139( let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = result.output.try_into().unwrap(); __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -16570,14 +16506,14 @@ fn aiur_fn_140( let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __v_17: G = __r_arr[3]; let __v_18: G = __r_arr[4]; let __v_19: G = __r_arr[5]; - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = result.output.try_into().unwrap(); __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -16620,7 +16556,7 @@ fn aiur_fn_141( let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_9]; record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16661,7 +16597,7 @@ fn aiur_fn_142( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_142] = [__v_6]; record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16738,7 +16674,7 @@ fn aiur_fn_143( _ => { match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = result.output.try_into().unwrap(); __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_48.as_canonical_u64() { 0u64 => { @@ -16953,7 +16889,7 @@ fn aiur_fn_145( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_145] = [__v_10]; record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -16992,7 +16928,7 @@ fn aiur_fn_146( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -17093,7 +17029,7 @@ fn aiur_fn_147( _ => { match __v_8.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() { 0u64 => { @@ -17101,7 +17037,7 @@ fn aiur_fn_147( break '__mc_0 [__v_60]; }, _ => { - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_59, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_59, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; break '__mc_0 [__v_60]; }, @@ -17110,9 +17046,9 @@ fn aiur_fn_147( let __v_60: G = __mc_out___mc_0[0]; match __v_60.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_59, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_59, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = __r_arr[2]; @@ -17125,7 +17061,7 @@ fn aiur_fn_147( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() { 0u64 => { @@ -17152,7 +17088,7 @@ fn aiur_fn_147( }; let __v_63: G = __mc_out___mc_2[0]; let __v_64: G = (__v_2 + __v_61); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -17170,7 +17106,7 @@ fn aiur_fn_147( } }, 6u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -17179,7 +17115,7 @@ fn aiur_fn_147( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -17188,7 +17124,7 @@ fn aiur_fn_147( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -17197,7 +17133,7 @@ fn aiur_fn_147( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -17208,7 +17144,7 @@ fn aiur_fn_147( 0u64 => { let __v_59: G = G::from_u64(1); let __v_60: G = (__v_2 + __v_59); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17219,7 +17155,7 @@ fn aiur_fn_147( 2u64 => { let __v_59: G = G::from_u64(1); let __v_60: G = (__v_2 + __v_59); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17230,7 +17166,7 @@ fn aiur_fn_147( 3u64 => { let __v_59: G = G::from_u64(1); let __v_60: G = (__v_2 + __v_59); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17241,7 +17177,7 @@ fn aiur_fn_147( 1u64 => { let __v_59: G = G::from_u64(1); let __v_60: G = (__v_2 + __v_59); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = result.output.try_into().unwrap(); __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17288,7 +17224,7 @@ fn aiur_fn_148( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_148] = [__v_10]; record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -17385,7 +17321,7 @@ fn aiur_fn_149( _ => { match __v_9.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() { 0u64 => { @@ -17393,7 +17329,7 @@ fn aiur_fn_149( break '__mc_0 [__v_61]; }, _ => { - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_60, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_60, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; break '__mc_0 [__v_61]; }, @@ -17402,10 +17338,10 @@ fn aiur_fn_149( let __v_61: G = __mc_out___mc_0[0]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_60, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = result.output.try_into().unwrap(); __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_60, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = { let __values: [G; 3] = [__v_63, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_65]; @@ -17413,7 +17349,7 @@ fn aiur_fn_149( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() { 0u64 => { @@ -17441,7 +17377,7 @@ fn aiur_fn_149( let __v_64: G = __mc_out___mc_2[0]; let __v_65: G = G::from_u64(0); let __v_66: G = (__v_3 + __v_62); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = { let __values: [G; 3] = [__v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_68]; @@ -17456,9 +17392,9 @@ fn aiur_fn_149( 6u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17511,13 +17447,13 @@ fn aiur_fn_149( _ => { match __v_61.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(0); let __v_112: G = (__v_60 + __v_110); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_114]; @@ -17536,9 +17472,9 @@ fn aiur_fn_149( 4u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_26, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_26, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17591,18 +17527,18 @@ fn aiur_fn_149( _ => { match __v_61.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(0); let __v_112: G = G::from_u64(1); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = (__v_112 + __v_113); let __v_115: G = (__v_110 + __v_114); let __v_116: G = (__v_60 + __v_115); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = { let __values: [G; 3] = [__v_111, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_118]; @@ -17621,9 +17557,9 @@ fn aiur_fn_149( 5u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17676,13 +17612,13 @@ fn aiur_fn_149( _ => { match __v_61.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(0); let __v_112: G = (__v_60 + __v_110); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_114]; @@ -17701,9 +17637,9 @@ fn aiur_fn_149( 7u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -17756,13 +17692,13 @@ fn aiur_fn_149( _ => { match __v_61.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(0); let __v_112: G = (__v_60 + __v_110); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_114]; @@ -17782,7 +17718,7 @@ fn aiur_fn_149( let __v_60: G = G::from_u64(0); let __v_61: G = G::from_u64(1); let __v_62: G = (__v_3 + __v_61); - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = result.output.try_into().unwrap(); __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = { let __values: [G; 3] = [__v_60, __v_3, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_149] = [__v_64]; @@ -17836,7 +17772,7 @@ fn aiur_fn_150( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -17847,11 +17783,11 @@ fn aiur_fn_150( let __v_13: G = __loaded[4]; let __v_14: G = __loaded[5]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = result.output.try_into().unwrap(); __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_17, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -17865,7 +17801,7 @@ fn aiur_fn_150( return Ok(__ret); }, 4294967295u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = result.output.try_into().unwrap(); __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); @@ -17963,7 +17899,7 @@ fn aiur_fn_151( _ => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = result.output.try_into().unwrap(); __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; match __v_49.as_canonical_u64() { 0u64 => { @@ -18033,7 +17969,7 @@ fn aiur_fn_152( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_152] = [__v_11]; record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18087,14 +18023,14 @@ fn aiur_fn_153( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = result.output.try_into().unwrap(); __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -18126,7 +18062,7 @@ fn aiur_fn_153( }; let __v_13: G = __mc_out___mc_2[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = result.output.try_into().unwrap(); __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 3] = [__v_14, __v_11, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_153] = [__v_16]; @@ -18163,7 +18099,7 @@ fn aiur_fn_154( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = result.output.try_into().unwrap(); __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_154] = [__v_8]; record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18208,11 +18144,11 @@ fn aiur_fn_155( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = result.output.try_into().unwrap(); __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -18224,20 +18160,20 @@ fn aiur_fn_155( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = result.output.try_into().unwrap(); __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -18282,7 +18218,7 @@ fn aiur_fn_156( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_4, __v_7, __v_8, __v_9, __v_9, __v_9, __v_9, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = result.output.try_into().unwrap(); __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_4, __v_7, __v_8, __v_9, __v_9, __v_9, __v_9, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -18328,7 +18264,7 @@ fn aiur_fn_157( let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_157] = [__v_14]; record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18351,7 +18287,7 @@ fn aiur_fn_158( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = result.output.try_into().unwrap(); __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_158] = [__v_3]; record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18430,10 +18366,10 @@ fn aiur_fn_159( }, 0u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = (__v_1 + __v_50); - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_48, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = result.output.try_into().unwrap(); __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_1, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_159] = [__v_53]; @@ -18478,7 +18414,7 @@ fn aiur_fn_160( let __v_8: G = (__v_0 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_8, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_8, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_3, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_160] = [__v_12]; @@ -18502,7 +18438,7 @@ fn aiur_fn_161( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_3]; record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18584,17 +18520,17 @@ fn aiur_fn_162( 1u64 => { match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_49, __v_1, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_49, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(1); let __v_53: G = (__v_52 + __v_49); let __v_54: G = (__v_1 + __v_53); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_56]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18605,7 +18541,7 @@ fn aiur_fn_162( 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_51]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18614,7 +18550,7 @@ fn aiur_fn_162( 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = result.output.try_into().unwrap(); __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_162] = [__v_51]; record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18707,7 +18643,7 @@ fn aiur_fn_163( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = result.output.try_into().unwrap(); __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_48]; record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -18753,9 +18689,9 @@ fn aiur_fn_164( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 11u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -18782,7 +18718,7 @@ fn aiur_fn_164( let __v_39: G = __loaded[15]; let __v_40: G = __loaded[16]; let __v_41: G = __loaded[17]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; @@ -18851,7 +18787,7 @@ fn aiur_fn_165( let __v_19: G = inp[19]; match __v_18.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -18875,7 +18811,7 @@ fn aiur_fn_165( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -18917,7 +18853,7 @@ fn aiur_fn_165( let __v_55: G = __loaded[17]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_18 - __v_56); - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = result.output.try_into().unwrap(); __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -18980,7 +18916,7 @@ fn aiur_fn_166( let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -19020,7 +18956,7 @@ fn aiur_fn_166( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = result.output.try_into().unwrap(); __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -19044,7 +18980,7 @@ fn aiur_fn_166( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = result.output.try_into().unwrap(); __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -19102,7 +19038,7 @@ fn aiur_fn_167( let __v_18: G = inp[18]; let __v_19: G = inp[19]; let __v_20: G = inp[20]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = result.output.try_into().unwrap(); __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -19142,7 +19078,7 @@ fn aiur_fn_167( let __v_54: G = __loaded[15]; let __v_55: G = __loaded[16]; let __v_56: G = __loaded[17]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = result.output.try_into().unwrap(); __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -19163,9 +19099,9 @@ fn aiur_fn_167( let __v_74: G = __r_arr[17]; match __v_57.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __ret: [G; OUT_167] = [__v_76]; record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19332,20 +19268,20 @@ fn aiur_fn_168( let __v_63: G = __loaded[15]; let __v_64: G = __loaded[16]; let __v_65: G = __loaded[17]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = (__v_68 + __v_69); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = (__v_70 + __v_71); - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_72, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = result.output.try_into().unwrap(); __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_72, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -19400,7 +19336,7 @@ fn aiur_fn_168( 6u64 => { match __v_75.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_122: G = __r_arr[0]; let __v_123: G = __r_arr[1]; let __v_124: G = __r_arr[2]; @@ -19453,11 +19389,11 @@ fn aiur_fn_168( _ => { match __v_122.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_83, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_83, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_170: G = __r_arr[0]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_171: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_123, __v_170, __v_171]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = result.output.try_into().unwrap(); __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_123, __v_170, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __ret: [G; OUT_168] = [__v_172, __v_83]; record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19497,7 +19433,7 @@ fn aiur_fn_169( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = result.output.try_into().unwrap(); __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_169] = [__v_4]; record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19577,7 +19513,7 @@ fn aiur_fn_170( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = result.output.try_into().unwrap(); __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = (__v_3 - __v_2); let __v_53: G = G::from_bool((__v_52 == G::ZERO)); @@ -19587,10 +19523,10 @@ fn aiur_fn_170( 1u64 => { match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_54, __v_1, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_54, __v_1, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_56]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19612,7 +19548,7 @@ fn aiur_fn_170( let __v_54: G = (__v_1 + __v_51); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_3 + __v_55); - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = result.output.try_into().unwrap(); __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_57]; record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -19701,17 +19637,17 @@ fn aiur_fn_171( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_50, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = (__v_51 + __v_58); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_57, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = result.output.try_into().unwrap(); __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_57, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = G::from_u64(4); let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_37, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = result.output.try_into().unwrap(); __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_37, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -19723,12 +19659,12 @@ fn aiur_fn_171( } }, 2u64 => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = result.output.try_into().unwrap(); __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; match __v_57.as_canonical_u64() { 1u64 => { let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50, __v_51, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = result.output.try_into().unwrap(); __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50, __v_51, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); @@ -19749,7 +19685,7 @@ fn aiur_fn_171( } }; let __v_58: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_53, __v_58, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = result.output.try_into().unwrap(); __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_53, __v_58, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = G::from_u64(3); @@ -19857,7 +19793,7 @@ fn aiur_fn_172( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 52] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_43, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_6, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = result.output.try_into().unwrap(); __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_172] = [__v_48]; @@ -19952,13 +19888,13 @@ fn aiur_fn_173( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = result.output.try_into().unwrap(); __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(1); let __v_62: G = (__v_8 + __v_61); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = result.output.try_into().unwrap(); __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_60, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __ret: [G; OUT_173] = [__v_64]; record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20016,14 +19952,14 @@ fn aiur_fn_175( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = result.output.try_into().unwrap(); __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; let __v_10: G = __r_arr[3]; let __v_11: G = __r_arr[4]; let __v_12: G = __r_arr[5]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = result.output.try_into().unwrap(); __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -20034,7 +19970,7 @@ fn aiur_fn_175( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_19, __v_3, __v_4, __v_5, __v_6, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_19, __v_3, __v_4, __v_5, __v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_175] = [__v_23]; record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20124,14 +20060,14 @@ fn aiur_fn_176( let __v_57: G = __loaded[45]; let __v_58: G = __loaded[46]; let __v_59: G = __loaded[47]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = result.output.try_into().unwrap(); __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; match __v_12.as_canonical_u64() { _ => { match __v_12.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = result.output.try_into().unwrap(); __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() { 0u64 => { @@ -20139,7 +20075,7 @@ fn aiur_fn_176( break '__mc_0 [__v_63]; }, _ => { - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_62, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = result.output.try_into().unwrap(); __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_62, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; break '__mc_0 [__v_63]; }, @@ -20148,7 +20084,7 @@ fn aiur_fn_176( let __v_63: G = __mc_out___mc_0[0]; match __v_63.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_64]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20167,25 +20103,25 @@ fn aiur_fn_176( } }; let __v_64: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = result.output.try_into().unwrap(); __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_60, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = result.output.try_into().unwrap(); __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_60, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_60, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = result.output.try_into().unwrap(); __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_60, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_66, __v_70]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = result.output.try_into().unwrap(); __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_66, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = G::from_u64(0); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_13, __v_57, __v_68, __v_71, __v_69, __v_59, __v_13, __v_66, __v_72, __v_58, __v_2, __v_6, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = result.output.try_into().unwrap(); __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_13, __v_57, __v_68, __v_71, __v_69, __v_59, __v_13, __v_66, __v_72, __v_58, __v_2, __v_6, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_7 + __v_65); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_76]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20197,35 +20133,35 @@ fn aiur_fn_176( } }, 6u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_62]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_62]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_62]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_176] = [__v_62]; record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = G::from_u64(0); @@ -20233,7 +20169,7 @@ fn aiur_fn_176( let __v_66: G = G::from_u64(1); let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_68: G = { let __values: [G; 3] = [__v_64, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_60]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = result.output.try_into().unwrap(); __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(0); @@ -20241,7 +20177,7 @@ fn aiur_fn_176( let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_68, __v_63, __v_59, __v_70, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_69, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_7 + __v_74); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_77]; @@ -20249,7 +20185,7 @@ fn aiur_fn_176( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = G::from_u64(1); @@ -20261,7 +20197,7 @@ fn aiur_fn_176( let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_71: G = G::from_u64(1); let __v_72: G = (__v_7 + __v_71); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_74]; @@ -20269,7 +20205,7 @@ fn aiur_fn_176( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = G::from_u64(1); @@ -20281,7 +20217,7 @@ fn aiur_fn_176( let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_71: G = G::from_u64(1); let __v_72: G = (__v_7 + __v_71); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_74]; @@ -20289,10 +20225,10 @@ fn aiur_fn_176( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = result.output.try_into().unwrap(); __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_58, __v_57, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = result.output.try_into().unwrap(); __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_58, __v_57, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); @@ -20305,7 +20241,7 @@ fn aiur_fn_176( let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_70, __v_63, __v_59, __v_71, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_64, __v_65]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_7 + __v_74); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = result.output.try_into().unwrap(); __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_176] = [__v_77]; @@ -20347,7 +20283,7 @@ fn aiur_fn_177( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -20362,7 +20298,7 @@ fn aiur_fn_177( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_15, __v_16]; @@ -20413,7 +20349,7 @@ fn aiur_fn_177( let __v_45: G = __io_pair.0; let __v_46: G = __io_pair.1; let __v_47: G = G::from_u64(4); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_47, __v_45, __v_46]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_47, __v_45, __v_46]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; @@ -20442,7 +20378,7 @@ fn aiur_fn_177( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_54, __v_55, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_54, __v_55, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_56, __v_57]; @@ -20458,14 +20394,14 @@ fn aiur_fn_177( let __v_53: G = G::from_u64(0); let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = G::from_u64(1); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; let __v_59: G = __r_arr[3]; let __v_60: G = __r_arr[4]; let __v_61: G = __r_arr[5]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; let __v_64: G = __r_arr[2]; @@ -20519,7 +20455,7 @@ fn aiur_fn_177( let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; match __v_62.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = result.output.try_into().unwrap(); __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = G::from_u64(0); let __v_115: G = G::from_u64(0); @@ -20554,16 +20490,16 @@ fn aiur_fn_177( let __v_144: G = G::from_u64(0); let __v_145: G = G::from_u64(0); let __v_146: G = { let __values: [G; 32] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_113, __v_146]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_113, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; match __v_147.as_canonical_u64() { 1u64 => { let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_150]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_151, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_153: G = __loaded[0]; @@ -20576,7 +20512,7 @@ fn aiur_fn_177( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_154, __v_155, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_154, __v_155, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_156, __v_157]; @@ -20594,9 +20530,9 @@ fn aiur_fn_177( let __v_150: G = G::from_u64(1); let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_152]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_153: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_153, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_154: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_155: G = __loaded[0]; @@ -20609,7 +20545,7 @@ fn aiur_fn_177( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_156, __v_157, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_156, __v_157, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_158: G = __r_arr[0]; let __v_159: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_158, __v_159]; @@ -20656,15 +20592,15 @@ fn aiur_fn_178( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = result.output.try_into().unwrap(); __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = result.output.try_into().unwrap(); __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -20673,11 +20609,11 @@ fn aiur_fn_178( let __v_23: G = __r_arr[5]; let __v_24: G = { let __values: [G; 6] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_12, __v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = result.output.try_into().unwrap(); __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_12, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_13, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = result.output.try_into().unwrap(); __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_13, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = result.output.try_into().unwrap(); __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -20686,9 +20622,9 @@ fn aiur_fn_178( let __v_33: G = __r_arr[5]; let __v_34: G = { let __values: [G; 6] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = result.output.try_into().unwrap(); __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_178] = [__v_37]; record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -20722,12 +20658,12 @@ fn aiur_fn_179( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = result.output.try_into().unwrap(); __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = result.output.try_into().unwrap(); __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_179] = [__v_11]; @@ -20910,7 +20846,7 @@ fn aiur_fn_181( 0u64 => { let __v_13: G = (__v_11 - __v_0); let __v_14: G = G::from_bool((__v_13 == G::ZERO)); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = result.output.try_into().unwrap(); __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 * __v_15); match __v_16.as_canonical_u64() { @@ -20921,7 +20857,7 @@ fn aiur_fn_181( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_6, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = result.output.try_into().unwrap(); __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_6, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_181] = [__v_17, __v_18]; @@ -21018,7 +20954,7 @@ fn aiur_fn_182( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = result.output.try_into().unwrap(); __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_182] = [__v_10]; record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21052,7 +20988,7 @@ fn aiur_fn_183( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = result.output.try_into().unwrap(); __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -21062,7 +20998,7 @@ fn aiur_fn_183( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = result.output.try_into().unwrap(); __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_6]; record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21118,19 +21054,19 @@ fn aiur_fn_184( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = result.output.try_into().unwrap(); __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_19 - __v_3); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -21142,7 +21078,7 @@ fn aiur_fn_184( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -21188,7 +21124,7 @@ fn aiur_fn_185( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -21196,7 +21132,7 @@ fn aiur_fn_185( let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_12, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = result.output.try_into().unwrap(); __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_12, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -21238,14 +21174,14 @@ fn aiur_fn_186( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = result.output.try_into().unwrap(); __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -21293,12 +21229,12 @@ fn aiur_fn_187( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_0 + __v_12); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = result.output.try_into().unwrap(); __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_11, __v_10, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_187] = [__v_15]; @@ -21397,9 +21333,9 @@ fn aiur_fn_188( 6u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = result.output.try_into().unwrap(); __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -21452,30 +21388,30 @@ fn aiur_fn_188( _ => { match __v_58.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_59, __v_106]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = result.output.try_into().unwrap(); __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_59, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_107 + __v_108); let __v_110: G = (__v_57 + __v_109); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = result.output.try_into().unwrap(); __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_59, __v_111]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = result.output.try_into().unwrap(); __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_59, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_110, __v_112, __v_113]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = result.output.try_into().unwrap(); __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_110, __v_112, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_114, __v_115]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = result.output.try_into().unwrap(); __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_114, __v_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_116: G = __r_arr[0]; let __ret: [G; OUT_188] = [__v_116]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; let __ret: [G; OUT_188] = [__v_106]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21488,7 +21424,7 @@ fn aiur_fn_188( } }, _ => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_188] = [__v_57]; record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21523,7 +21459,7 @@ fn aiur_fn_189( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = result.output.try_into().unwrap(); __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_189] = [__v_3]; record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21607,7 +21543,7 @@ fn aiur_fn_190( 1u64 => { match __v_5.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_190] = [__v_51]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21626,7 +21562,7 @@ fn aiur_fn_190( _ => { let __v_51: G = G::from_u64(1); let __v_52: G = (__v_2 + __v_51); - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_49, __v_1, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = result.output.try_into().unwrap(); __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_49, __v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __ret: [G; OUT_190] = [__v_53]; record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21674,13 +21610,13 @@ fn aiur_fn_191( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = result.output.try_into().unwrap(); __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = (__v_9 + __v_11); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_11 + __v_16); - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = result.output.try_into().unwrap(); __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 4] = [__v_14, __v_15, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_191] = [__v_19]; @@ -21732,9 +21668,9 @@ fn aiur_fn_192( let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_17, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_9, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_21, __v_24, __v_27, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_17, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_9, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_21, __v_24, __v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __ret: [G; OUT_192] = [__v_32]; record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21764,10 +21700,10 @@ fn aiur_fn_193( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = result.output.try_into().unwrap(); __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_193] = [__v_14, __v_15]; @@ -21793,7 +21729,7 @@ fn aiur_fn_194( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = result.output.try_into().unwrap(); __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_4, __v_5]; @@ -21809,10 +21745,10 @@ fn aiur_fn_194( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = result.output.try_into().unwrap(); __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = result.output.try_into().unwrap(); __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_194] = [__v_14, __v_15]; @@ -21839,11 +21775,11 @@ fn aiur_fn_195( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = result.output.try_into().unwrap(); __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = result.output.try_into().unwrap(); __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -21852,11 +21788,11 @@ fn aiur_fn_195( let __v_11: G = __r_arr[5]; let __v_12: G = { let __values: [G; 6] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = result.output.try_into().unwrap(); __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = result.output.try_into().unwrap(); __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = result.output.try_into().unwrap(); __ret } else { aiur_fn_156(__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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -21865,20 +21801,20 @@ fn aiur_fn_195( let __v_21: G = __r_arr[5]; let __v_22: G = { let __values: [G; 6] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = result.output.try_into().unwrap(); __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = result.output.try_into().unwrap(); __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = result.output.try_into().unwrap(); __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; let __v_30: G = __r_arr[4]; let __v_31: G = __r_arr[5]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1, __v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = result.output.try_into().unwrap(); __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1, __v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = result.output.try_into().unwrap(); __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -21919,14 +21855,14 @@ fn aiur_fn_195( let __v_70: G = G::from_u64(0); let __v_71: G = { let __values: [G; 32] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_72: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_72, __v_5, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = result.output.try_into().unwrap(); __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_72, __v_5, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = result.output.try_into().unwrap(); __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_25, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_76, __v_77]; record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21944,7 +21880,7 @@ fn aiur_fn_196( unconstrained: bool, ) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = result.output.try_into().unwrap(); __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_0: G = __r_arr[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); @@ -21957,9 +21893,9 @@ fn aiur_fn_196( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 11] = [__v_7, __v_8, __v_6, __v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = result.output.try_into().unwrap(); __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_13, __v_0]; record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -21978,211 +21914,211 @@ fn aiur_fn_197( ) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = result.output.try_into().unwrap(); __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = result.output.try_into().unwrap(); __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = result.output.try_into().unwrap(); __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = result.output.try_into().unwrap(); __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = result.output.try_into().unwrap(); __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = result.output.try_into().unwrap(); __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = result.output.try_into().unwrap(); __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = result.output.try_into().unwrap(); __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = result.output.try_into().unwrap(); __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = result.output.try_into().unwrap(); __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = result.output.try_into().unwrap(); __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = result.output.try_into().unwrap(); __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = result.output.try_into().unwrap(); __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = result.output.try_into().unwrap(); __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(0); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = result.output.try_into().unwrap(); __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = G::from_u64(0); - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = G::from_u64(0); - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(0); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(0); - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; let __v_86: G = G::from_u64(0); - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = G::from_u64(0); - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(0); - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(0); - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; let __v_94: G = G::from_u64(0); - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; let __v_98: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_99: G = __r_arr[0]; let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; let __v_102: G = G::from_u64(0); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = G::from_u64(0); - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = G::from_u64(0); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; let __v_110: G = G::from_u64(0); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = G::from_u64(0); - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = result.output.try_into().unwrap(); __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = G::from_u64(0); - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(0); - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = G::from_u64(0); - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = G::from_u64(0); - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = G::from_u64(0); - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = result.output.try_into().unwrap(); __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = G::from_u64(0); - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = G::from_u64(0); - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = result.output.try_into().unwrap(); __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = result.output.try_into().unwrap(); __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = result.output.try_into().unwrap(); __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = G::from_u64(0); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = result.output.try_into().unwrap(); __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_133: G = __r_arr[0]; let __v_134: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_135: G = __r_arr[0]; let __v_136: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); @@ -22285,7 +22221,7 @@ fn aiur_fn_198( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); @@ -22325,7 +22261,7 @@ fn aiur_fn_199( let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 - __v_3); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = result.output.try_into().unwrap(); __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_199] = [__v_6]; @@ -22354,10 +22290,10 @@ fn aiur_fn_200( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_5, __v_7]; record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22416,9 +22352,9 @@ fn aiur_fn_201( let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -22450,7 +22386,7 @@ fn aiur_fn_201( let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_201] = [__v_6]; record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22507,7 +22443,7 @@ fn aiur_fn_202( let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_12]; record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22540,9 +22476,9 @@ fn aiur_fn_202( let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 * __v_19); let __ret: [G; OUT_202] = [__v_20]; @@ -22576,9 +22512,9 @@ fn aiur_fn_202( let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 * __v_19); let __ret: [G; OUT_202] = [__v_20]; @@ -22688,7 +22624,7 @@ fn aiur_fn_203( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_203] = [__v_10]; record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22764,14 +22700,14 @@ fn aiur_fn_204( let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_10]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__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_10: G = __r_arr[0]; let __ret: [G; OUT_204] = [__v_10]; record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22852,7 +22788,7 @@ fn aiur_fn_205( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = result.output.try_into().unwrap(); __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_205] = [__v_8]; record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -22919,7 +22855,7 @@ fn aiur_fn_206( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); @@ -22995,7 +22931,7 @@ fn aiur_fn_207( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = result.output.try_into().unwrap(); __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_207] = [__v_12]; @@ -23111,7 +23047,7 @@ fn aiur_fn_208( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = result.output.try_into().unwrap(); __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_208] = [__v_14]; record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23177,7 +23113,7 @@ fn aiur_fn_209( let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = result.output.try_into().unwrap(); __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { @@ -23253,7 +23189,7 @@ fn aiur_fn_210( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_210] = [__v_15]; @@ -23264,7 +23200,7 @@ fn aiur_fn_210( let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_14]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23275,7 +23211,7 @@ fn aiur_fn_210( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_210] = [__v_17]; @@ -23283,7 +23219,7 @@ fn aiur_fn_210( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_15]; record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23346,7 +23282,7 @@ fn aiur_fn_211( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_6]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23363,7 +23299,7 @@ fn aiur_fn_211( } }, _ => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_3]; record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23412,7 +23348,7 @@ fn aiur_fn_212( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -23449,7 +23385,7 @@ fn aiur_fn_212( }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = result.output.try_into().unwrap(); __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_212] = [__v_12]; @@ -23511,12 +23447,12 @@ fn aiur_fn_213( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = result.output.try_into().unwrap(); __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -23541,7 +23477,7 @@ fn aiur_fn_213( }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_213] = [__v_13]; @@ -23577,7 +23513,7 @@ fn aiur_fn_214( let __v_5: G = inp[5]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_6]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23590,7 +23526,7 @@ fn aiur_fn_214( let __v_8: G = __loaded[2]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_11]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23605,9 +23541,9 @@ fn aiur_fn_214( let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_3, __v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_13]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23622,21 +23558,21 @@ fn aiur_fn_214( let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_12]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_7, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_7, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_9]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23650,7 +23586,7 @@ fn aiur_fn_214( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_3, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_3, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_214] = [__v_8]; record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23691,7 +23627,7 @@ fn aiur_fn_215( let __v_8: G = inp[8]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_9]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23704,9 +23640,9 @@ fn aiur_fn_215( let __v_11: G = __loaded[2]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_7 + __v_12); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_6, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_6, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_15]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23721,9 +23657,9 @@ fn aiur_fn_215( let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_9, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_9, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_16]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23738,25 +23674,25 @@ fn aiur_fn_215( let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = result.output.try_into().unwrap(); __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_16]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = result.output.try_into().unwrap(); __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = result.output.try_into().unwrap(); __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_10, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_10, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_10, __v_7, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_10, __v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_13]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23768,14 +23704,14 @@ fn aiur_fn_215( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_6, __v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = result.output.try_into().unwrap(); __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_6, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, } }; let __v_11: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_12]; record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -23817,9 +23753,9 @@ fn aiur_fn_216( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = result.output.try_into().unwrap(); __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_216] = [__v_8]; @@ -23868,18 +23804,18 @@ fn aiur_fn_217( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_12]; record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = result.output.try_into().unwrap(); __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -23912,7 +23848,7 @@ fn aiur_fn_217( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = result.output.try_into().unwrap(); __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -23953,7 +23889,7 @@ fn aiur_fn_217( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = result.output.try_into().unwrap(); __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -23969,7 +23905,7 @@ fn aiur_fn_217( }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_15, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = result.output.try_into().unwrap(); __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_217] = [__v_16]; record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24053,18 +23989,18 @@ fn aiur_fn_218( let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = result.output.try_into().unwrap(); __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = (__v_9 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = result.output.try_into().unwrap(); __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = result.output.try_into().unwrap(); __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_17]; record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24144,11 +24080,11 @@ fn aiur_fn_219( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_10]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24162,7 +24098,7 @@ fn aiur_fn_219( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = result.output.try_into().unwrap(); __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -24180,7 +24116,7 @@ fn aiur_fn_219( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_12]; record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24242,7 +24178,7 @@ fn aiur_fn_220( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = result.output.try_into().unwrap(); __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_10]; record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24294,18 +24230,18 @@ fn aiur_fn_221( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = result.output.try_into().unwrap(); __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_11]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -24315,7 +24251,7 @@ fn aiur_fn_221( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_12]; record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24379,7 +24315,7 @@ fn aiur_fn_222( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_10]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24391,7 +24327,7 @@ fn aiur_fn_222( } }, _ => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = result.output.try_into().unwrap(); __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_222] = [__v_9]; record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24444,7 +24380,7 @@ fn aiur_fn_223( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = result.output.try_into().unwrap(); __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -24459,7 +24395,7 @@ fn aiur_fn_223( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_7, __v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = result.output.try_into().unwrap(); __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -24469,7 +24405,7 @@ fn aiur_fn_223( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = result.output.try_into().unwrap(); __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_223] = [__v_10]; record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24524,7 +24460,7 @@ fn aiur_fn_224( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = result.output.try_into().unwrap(); __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { @@ -24534,7 +24470,7 @@ fn aiur_fn_224( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = result.output.try_into().unwrap(); __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_224] = [__v_9]; record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24584,9 +24520,9 @@ fn aiur_fn_225( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_18, __v_19, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = result.output.try_into().unwrap(); __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_18, __v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_20, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = result.output.try_into().unwrap(); __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_20, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_225] = [__v_21]; record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24610,7 +24546,7 @@ fn aiur_fn_226( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -24628,11 +24564,11 @@ fn aiur_fn_226( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = result.output.try_into().unwrap(); __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_226] = [__v_9]; record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24663,7 +24599,7 @@ fn aiur_fn_227( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -24673,11 +24609,11 @@ fn aiur_fn_227( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = result.output.try_into().unwrap(); __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = result.output.try_into().unwrap(); __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_9]; record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -24720,7 +24656,7 @@ fn aiur_fn_228( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -24742,7 +24678,7 @@ fn aiur_fn_228( let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -24808,7 +24744,7 @@ fn aiur_fn_229( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -24817,11 +24753,11 @@ fn aiur_fn_229( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -24837,7 +24773,7 @@ fn aiur_fn_229( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -24903,7 +24839,7 @@ fn aiur_fn_230( let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -24922,15 +24858,15 @@ fn aiur_fn_230( let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -24947,15 +24883,15 @@ fn aiur_fn_230( let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -24998,7 +24934,7 @@ fn aiur_fn_231( let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -25017,15 +24953,15 @@ fn aiur_fn_231( let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = result.output.try_into().unwrap(); __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -25042,15 +24978,15 @@ fn aiur_fn_231( let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -25059,7 +24995,7 @@ fn aiur_fn_231( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -25107,12 +25043,12 @@ fn aiur_fn_232( let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __v_12: G = { let __values: [G; 3] = [__v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = result.output.try_into().unwrap(); __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 3] = [__v_8, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_232] = [__v_14]; @@ -25149,7 +25085,7 @@ fn aiur_fn_233( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = result.output.try_into().unwrap(); __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_233] = [__v_5]; record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25191,7 +25127,7 @@ fn aiur_fn_234( let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_7, __v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = result.output.try_into().unwrap(); __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_7, __v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25204,7 +25140,7 @@ fn aiur_fn_234( }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = result.output.try_into().unwrap(); __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -25214,9 +25150,9 @@ fn aiur_fn_234( }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -25226,9 +25162,9 @@ fn aiur_fn_234( }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -25238,9 +25174,9 @@ fn aiur_fn_234( }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -25250,11 +25186,11 @@ fn aiur_fn_234( }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_234] = [__v_10]; @@ -25271,7 +25207,7 @@ fn aiur_fn_234( }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_234] = [__v_8]; @@ -25356,11 +25292,11 @@ fn aiur_fn_235( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[6].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = result.output.try_into().unwrap(); __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[6].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = unsafe { *(result.output.as_ptr() as *const [G; OUT_6]) }; __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_235] = [__v_23]; record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25442,7 +25378,7 @@ fn aiur_fn_236( let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_236] = [__v_9]; record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25486,7 +25422,7 @@ fn aiur_fn_237( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_4]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -25503,7 +25439,7 @@ fn aiur_fn_237( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_237] = [__v_4]; record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -28955,7 +28891,7 @@ fn aiur_fn_307( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -28975,7 +28911,7 @@ fn aiur_fn_307( }, _ => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_307] = [__v_30]; @@ -29024,7 +28960,7 @@ fn aiur_fn_308( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_308] = [__v_13]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29053,7 +28989,7 @@ fn aiur_fn_308( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_308] = [__v_23]; record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29062,7 +28998,7 @@ fn aiur_fn_308( } }, 0u64 => { - let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -29079,7 +29015,7 @@ fn aiur_fn_308( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -29091,7 +29027,7 @@ fn aiur_fn_308( let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_12, __v_22, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = result.output.try_into().unwrap(); __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_308] = [__v_51]; @@ -29123,7 +29059,7 @@ fn aiur_fn_309( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = result.output.try_into().unwrap(); __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_3]; record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29157,55 +29093,55 @@ fn aiur_fn_310( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_0, &__v_8); let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.push(Bytes2::sub(&__v_0, &__v_8).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record) }; let __v_16: G = __b2_sub.0; let __v_17: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_1, &__v_9); let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.push(Bytes2::sub(&__v_1, &__v_9).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record) }; let __v_18: G = __b2_sub.0; let __v_19: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_18, &__v_17); let mut __scratch: Vec = vec![__v_18, __v_17]; if unconstrained { __scratch.push(Bytes2::sub(&__v_18, &__v_17).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record) }; let __v_20: G = __b2_sub.0; let __v_21: G = __b2_sub.1; let __v_22: G = (__v_19 + __v_21); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_2, &__v_10); let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.push(Bytes2::sub(&__v_2, &__v_10).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record) }; let __v_23: G = __b2_sub.0; let __v_24: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_23, &__v_22); let mut __scratch: Vec = vec![__v_23, __v_22]; if unconstrained { __scratch.push(Bytes2::sub(&__v_23, &__v_22).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record) }; let __v_25: G = __b2_sub.0; let __v_26: G = __b2_sub.1; let __v_27: G = (__v_24 + __v_26); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_3, &__v_11); let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.push(Bytes2::sub(&__v_3, &__v_11).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record) }; let __v_28: G = __b2_sub.0; let __v_29: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_28, &__v_27); let mut __scratch: Vec = vec![__v_28, __v_27]; if unconstrained { __scratch.push(Bytes2::sub(&__v_28, &__v_27).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record) }; let __v_30: G = __b2_sub.0; let __v_31: G = __b2_sub.1; let __v_32: G = (__v_29 + __v_31); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_4, &__v_12); let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.push(Bytes2::sub(&__v_4, &__v_12).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record) }; let __v_33: G = __b2_sub.0; let __v_34: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_33, &__v_32); let mut __scratch: Vec = vec![__v_33, __v_32]; if unconstrained { __scratch.push(Bytes2::sub(&__v_33, &__v_32).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record) }; let __v_35: G = __b2_sub.0; let __v_36: G = __b2_sub.1; let __v_37: G = (__v_34 + __v_36); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_5, &__v_13); let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.push(Bytes2::sub(&__v_5, &__v_13).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record) }; let __v_38: G = __b2_sub.0; let __v_39: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_38, &__v_37); let mut __scratch: Vec = vec![__v_38, __v_37]; if unconstrained { __scratch.push(Bytes2::sub(&__v_38, &__v_37).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record) }; let __v_40: G = __b2_sub.0; let __v_41: G = __b2_sub.1; let __v_42: G = (__v_39 + __v_41); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_6, &__v_14); let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.push(Bytes2::sub(&__v_6, &__v_14).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record) }; let __v_43: G = __b2_sub.0; let __v_44: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_43, &__v_42); let mut __scratch: Vec = vec![__v_43, __v_42]; if unconstrained { __scratch.push(Bytes2::sub(&__v_43, &__v_42).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record) }; let __v_45: G = __b2_sub.0; let __v_46: G = __b2_sub.1; let __v_47: G = (__v_44 + __v_46); - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_7, &__v_15); let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.push(Bytes2::sub(&__v_7, &__v_15).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record) }; let __v_48: G = __b2_sub.0; let __v_49: G = __b2_sub.1; - let __b2_sub: (G, G) = { let (_, __borrow) = Bytes2::sub(&__v_48, &__v_47); let mut __scratch: Vec = vec![__v_48, __v_47]; if unconstrained { __scratch.push(Bytes2::sub(&__v_48, &__v_47).0); } else { bytes2_execute(0, 1, &Bytes2Op::Sub, &mut __scratch, record); } (__scratch[2], __borrow) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record) }; let __v_50: G = __b2_sub.0; let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); @@ -29305,7 +29241,7 @@ fn aiur_fn_311( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -29318,7 +29254,7 @@ fn aiur_fn_311( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_42, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); @@ -29330,7 +29266,7 @@ fn aiur_fn_311( } }, 0u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -29347,7 +29283,7 @@ fn aiur_fn_311( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = result.output.try_into().unwrap(); __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -29358,7 +29294,7 @@ fn aiur_fn_311( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_22, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); @@ -29411,7 +29347,7 @@ fn aiur_fn_312( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -29426,7 +29362,7 @@ fn aiur_fn_312( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -29481,7 +29417,7 @@ fn aiur_fn_313( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = result.output.try_into().unwrap(); __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -29494,7 +29430,7 @@ fn aiur_fn_313( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_5]; record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29519,7 +29455,7 @@ fn aiur_fn_314( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -29573,7 +29509,7 @@ fn aiur_fn_315( let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_14]; record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -29606,7 +29542,7 @@ fn aiur_fn_316( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_316] = [__v_8, __v_9]; @@ -29632,11 +29568,11 @@ fn aiur_fn_317( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_317] = [__v_2, __v_5, __v_6]; @@ -29784,19 +29720,16 @@ fn aiur_fn_318( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_16]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; let __v_132: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_129, __v_132]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_129, &__v_132)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_133: G = __b2_out[0]; + let __v_133: G = if unconstrained { Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record) }; let __v_134: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_130, __v_134]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_130, &__v_134)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_135: G = __b2_out[0]; + let __v_135: G = if unconstrained { Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record) }; let __v_136: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_131, __v_136]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_131, &__v_136)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_137: G = __b2_out[0]; + let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) }; let __v_138: G = G::from_u64(256); let __v_139: G = (__v_138 * __v_135); let __v_140: G = G::from_u64(65536); @@ -29810,19 +29743,16 @@ fn aiur_fn_318( let __v_145: G = (__v_144 * __v_137); let __v_146: G = (__v_135 + __v_145); let __v_147: G = (__v_19 + __v_146); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_147]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_147]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; let __v_151: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_148, __v_151]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_148, &__v_151)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_152: G = __b2_out[0]; + let __v_152: G = if unconstrained { Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record) }; let __v_153: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_149, __v_153]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_149, &__v_153)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_154: G = __b2_out[0]; + let __v_154: G = if unconstrained { Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record) }; let __v_155: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_150, __v_155]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_150, &__v_155)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_156: G = __b2_out[0]; + let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) }; let __v_157: G = G::from_u64(256); let __v_158: G = (__v_157 * __v_154); let __v_159: G = G::from_u64(65536); @@ -29836,19 +29766,16 @@ fn aiur_fn_318( let __v_164: G = (__v_163 * __v_156); let __v_165: G = (__v_154 + __v_164); let __v_166: G = (__v_24 + __v_165); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_166]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_166]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; let __v_170: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_167, __v_170]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_167, &__v_170)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_171: G = __b2_out[0]; + let __v_171: G = if unconstrained { Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record) }; let __v_172: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_168, __v_172]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_168, &__v_172)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_173: G = __b2_out[0]; + let __v_173: G = if unconstrained { Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record) }; let __v_174: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_169, __v_174]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_169, &__v_174)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_175: G = __b2_out[0]; + let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) }; let __v_176: G = G::from_u64(256); let __v_177: G = (__v_176 * __v_173); let __v_178: G = G::from_u64(65536); @@ -29862,19 +29789,16 @@ fn aiur_fn_318( let __v_183: G = (__v_182 * __v_175); let __v_184: G = (__v_173 + __v_183); let __v_185: G = (__v_31 + __v_184); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_185]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_185]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_186, __v_189]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_186, &__v_189)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_190: G = __b2_out[0]; + let __v_190: G = if unconstrained { Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record) }; let __v_191: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_187, __v_191]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_187, &__v_191)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_192: G = __b2_out[0]; + let __v_192: G = if unconstrained { Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record) }; let __v_193: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_188, __v_193]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_188, &__v_193)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_194: G = __b2_out[0]; + let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) }; let __v_195: G = G::from_u64(256); let __v_196: G = (__v_195 * __v_192); let __v_197: G = G::from_u64(65536); @@ -29888,19 +29812,16 @@ fn aiur_fn_318( let __v_202: G = (__v_201 * __v_194); let __v_203: G = (__v_192 + __v_202); let __v_204: G = (__v_40 + __v_203); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_204]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_204]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; let __v_208: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_205, __v_208]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_205, &__v_208)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_209: G = __b2_out[0]; + let __v_209: G = if unconstrained { Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record) }; let __v_210: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_206, __v_210]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_206, &__v_210)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_211: G = __b2_out[0]; + let __v_211: G = if unconstrained { Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record) }; let __v_212: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_207, __v_212]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_207, &__v_212)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_213: G = __b2_out[0]; + let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) }; let __v_214: G = G::from_u64(256); let __v_215: G = (__v_214 * __v_211); let __v_216: G = G::from_u64(65536); @@ -29914,19 +29835,16 @@ fn aiur_fn_318( let __v_221: G = (__v_220 * __v_213); let __v_222: G = (__v_211 + __v_221); let __v_223: G = (__v_51 + __v_222); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_223]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_223]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; let __v_227: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_224, __v_227]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_224, &__v_227)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_228: G = __b2_out[0]; + let __v_228: G = if unconstrained { Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record) }; let __v_229: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_225, __v_229]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_225, &__v_229)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_230: G = __b2_out[0]; + let __v_230: G = if unconstrained { Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record) }; let __v_231: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_226, __v_231]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_226, &__v_231)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_232: G = __b2_out[0]; + let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) }; let __v_233: G = G::from_u64(256); let __v_234: G = (__v_233 * __v_230); let __v_235: G = G::from_u64(65536); @@ -29940,19 +29858,16 @@ fn aiur_fn_318( let __v_240: G = (__v_239 * __v_232); let __v_241: G = (__v_230 + __v_240); let __v_242: G = (__v_64 + __v_241); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_242]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_242]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; let __v_246: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_243, __v_246]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_243, &__v_246)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_247: G = __b2_out[0]; + let __v_247: G = if unconstrained { Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record) }; let __v_248: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_244, __v_248]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_244, &__v_248)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_249: G = __b2_out[0]; + let __v_249: G = if unconstrained { Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record) }; let __v_250: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_245, __v_250]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_245, &__v_250)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_251: G = __b2_out[0]; + let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) }; let __v_252: G = G::from_u64(256); let __v_253: G = (__v_252 * __v_249); let __v_254: G = G::from_u64(65536); @@ -29966,19 +29881,16 @@ fn aiur_fn_318( let __v_259: G = (__v_258 * __v_251); let __v_260: G = (__v_249 + __v_259); let __v_261: G = (__v_79 + __v_260); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_261]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_261]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; let __v_265: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_262, __v_265]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_262, &__v_265)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_266: G = __b2_out[0]; + let __v_266: G = if unconstrained { Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record) }; let __v_267: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_263, __v_267]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_263, &__v_267)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_268: G = __b2_out[0]; + let __v_268: G = if unconstrained { Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record) }; let __v_269: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_264, __v_269]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_264, &__v_269)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_270: G = __b2_out[0]; + let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) }; let __v_271: G = G::from_u64(256); let __v_272: G = (__v_271 * __v_268); let __v_273: G = G::from_u64(65536); @@ -29992,19 +29904,16 @@ fn aiur_fn_318( let __v_278: G = (__v_277 * __v_270); let __v_279: G = (__v_268 + __v_278); let __v_280: G = (__v_92 + __v_279); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_280]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_280]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; let __v_284: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_281, __v_284]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_281, &__v_284)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_285: G = __b2_out[0]; + let __v_285: G = if unconstrained { Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record) }; let __v_286: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_282, __v_286]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_282, &__v_286)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_287: G = __b2_out[0]; + let __v_287: G = if unconstrained { Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record) }; let __v_288: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_283, __v_288]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_283, &__v_288)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_289: G = __b2_out[0]; + let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) }; let __v_290: G = G::from_u64(256); let __v_291: G = (__v_290 * __v_287); let __v_292: G = G::from_u64(65536); @@ -30018,19 +29927,16 @@ fn aiur_fn_318( let __v_297: G = (__v_296 * __v_289); let __v_298: G = (__v_287 + __v_297); let __v_299: G = (__v_103 + __v_298); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_299]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_299]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; let __v_303: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_300, __v_303]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_300, &__v_303)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_304: G = __b2_out[0]; + let __v_304: G = if unconstrained { Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record) }; let __v_305: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_301, __v_305]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_301, &__v_305)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_306: G = __b2_out[0]; + let __v_306: G = if unconstrained { Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record) }; let __v_307: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_302, __v_307]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_302, &__v_307)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_308: G = __b2_out[0]; + let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) }; let __v_309: G = G::from_u64(256); let __v_310: G = (__v_309 * __v_306); let __v_311: G = G::from_u64(65536); @@ -30044,19 +29950,16 @@ fn aiur_fn_318( let __v_316: G = (__v_315 * __v_308); let __v_317: G = (__v_306 + __v_316); let __v_318: G = (__v_112 + __v_317); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_318]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_318]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; let __v_322: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_319, __v_322]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_319, &__v_322)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_323: G = __b2_out[0]; + let __v_323: G = if unconstrained { Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record) }; let __v_324: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_320, __v_324]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_320, &__v_324)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_325: G = __b2_out[0]; + let __v_325: G = if unconstrained { Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record) }; let __v_326: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_321, __v_326]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_321, &__v_326)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_327: G = __b2_out[0]; + let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) }; let __v_328: G = G::from_u64(256); let __v_329: G = (__v_328 * __v_325); let __v_330: G = G::from_u64(65536); @@ -30070,19 +29973,16 @@ fn aiur_fn_318( let __v_335: G = (__v_334 * __v_327); let __v_336: G = (__v_325 + __v_335); let __v_337: G = (__v_119 + __v_336); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_337]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_337]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; let __v_341: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_338, __v_341]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_338, &__v_341)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_342: G = __b2_out[0]; + let __v_342: G = if unconstrained { Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record) }; let __v_343: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_339, __v_343]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_339, &__v_343)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_344: G = __b2_out[0]; + let __v_344: G = if unconstrained { Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record) }; let __v_345: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_340, __v_345]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_340, &__v_345)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_346: G = __b2_out[0]; + let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) }; let __v_347: G = G::from_u64(256); let __v_348: G = (__v_347 * __v_344); let __v_349: G = G::from_u64(65536); @@ -30096,19 +29996,16 @@ fn aiur_fn_318( let __v_354: G = (__v_353 * __v_346); let __v_355: G = (__v_344 + __v_354); let __v_356: G = (__v_124 + __v_355); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_356]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_356]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; let __v_360: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_357, __v_360]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_357, &__v_360)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_361: G = __b2_out[0]; + let __v_361: G = if unconstrained { Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record) }; let __v_362: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_358, __v_362]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_358, &__v_362)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_363: G = __b2_out[0]; + let __v_363: G = if unconstrained { Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record) }; let __v_364: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_359, __v_364]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_359, &__v_364)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_365: G = __b2_out[0]; + let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) }; let __v_366: G = G::from_u64(256); let __v_367: G = (__v_366 * __v_363); let __v_368: G = G::from_u64(65536); @@ -30122,19 +30019,16 @@ fn aiur_fn_318( let __v_373: G = (__v_372 * __v_365); let __v_374: G = (__v_363 + __v_373); let __v_375: G = (__v_127 + __v_374); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_375]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_375]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; let __v_379: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_376, __v_379]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_376, &__v_379)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_380: G = __b2_out[0]; + let __v_380: G = if unconstrained { Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record) }; let __v_381: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_377, __v_381]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_377, &__v_381)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_382: G = __b2_out[0]; + let __v_382: G = if unconstrained { Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record) }; let __v_383: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_378, __v_383]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_378, &__v_383)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_384: G = __b2_out[0]; + let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) }; let __v_385: G = G::from_u64(256); let __v_386: G = (__v_385 * __v_382); let __v_387: G = G::from_u64(65536); @@ -30148,19 +30042,16 @@ fn aiur_fn_318( let __v_392: G = (__v_391 * __v_384); let __v_393: G = (__v_382 + __v_392); let __v_394: G = (__v_128 + __v_393); - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_394]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = result.output.try_into().unwrap(); __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_394]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; let __v_398: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_395, __v_398]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_395, &__v_398)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_399: G = __b2_out[0]; + let __v_399: G = if unconstrained { Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record) }; let __v_400: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_396, __v_400]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_396, &__v_400)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_401: G = __b2_out[0]; + let __v_401: G = if unconstrained { Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record) }; let __v_402: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_397, __v_402]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_397, &__v_402)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_403: G = __b2_out[0]; + let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) }; let __v_404: G = G::from_u64(256); let __v_405: G = (__v_404 * __v_401); let __v_406: G = G::from_u64(65536); @@ -30195,7 +30086,7 @@ fn aiur_fn_319( let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = result.output.try_into().unwrap(); __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_6]; record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30246,15 +30137,15 @@ fn aiur_fn_320( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = result.output.try_into().unwrap(); __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_25, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = result.output.try_into().unwrap(); __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_2, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = result.output.try_into().unwrap(); __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_30]; record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30308,7 +30199,7 @@ fn aiur_fn_321( let __v_27: G = __loaded[9]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -30317,7 +30208,7 @@ fn aiur_fn_321( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_29]; record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30329,7 +30220,7 @@ fn aiur_fn_321( } }, 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = result.output.try_into().unwrap(); __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -30346,7 +30237,7 @@ fn aiur_fn_321( let __v_41: G = __r_arr[13]; let __v_42: G = __r_arr[14]; let __v_43: G = __r_arr[15]; - let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -30363,7 +30254,7 @@ fn aiur_fn_321( let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = result.output.try_into().unwrap(); __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __v_62: G = __r_arr[2]; @@ -30373,9 +30264,9 @@ fn aiur_fn_321( let __v_66: G = __r_arr[6]; let __v_67: G = __r_arr[7]; let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = result.output.try_into().unwrap(); __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_70]; record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30419,7 +30310,7 @@ fn aiur_fn_322( let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_11, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = result.output.try_into().unwrap(); __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_14]; record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30440,7 +30331,7 @@ fn aiur_fn_323( ) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -30485,18 +30376,18 @@ fn aiur_fn_324( let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); } - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -30505,9 +30396,9 @@ fn aiur_fn_324( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); if (__v_10 != __v_11) { @@ -30536,7 +30427,7 @@ fn aiur_fn_325( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_325] = [__v_2]; @@ -30557,7 +30448,7 @@ fn aiur_fn_326( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_326] = [__v_3]; @@ -30578,7 +30469,7 @@ fn aiur_fn_327( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -30587,9 +30478,9 @@ fn aiur_fn_327( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = result.output.try_into().unwrap(); __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_327] = [__v_4]; record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30614,7 +30505,7 @@ fn aiur_fn_328( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -30649,18 +30540,18 @@ fn aiur_fn_328( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = result.output.try_into().unwrap(); __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -30669,7 +30560,7 @@ fn aiur_fn_328( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_23]; record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -30713,22 +30604,14 @@ fn aiur_fn_329( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_16: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_17: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_18: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_19: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_20: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_21: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_22: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::and(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::And, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_23: G = __b2_out[0]; + let __v_16: G = if unconstrained { Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; let __ret: [G; OUT_329] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -30761,22 +30644,14 @@ fn aiur_fn_330( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_16: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_17: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_18: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_19: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_20: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_21: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_22: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::or(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::Or, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_23: G = __b2_out[0]; + let __v_16: G = if unconstrained { Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; let __ret: [G; OUT_330] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -30809,22 +30684,14 @@ fn aiur_fn_331( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_8]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_0, &__v_8)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_16: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_17: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_10]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_10)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_18: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_19: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_12]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_12)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_20: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_5, __v_13]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_5, &__v_13)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_21: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_6, __v_14]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_6, &__v_14)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_22: G = __b2_out[0]; - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_7, __v_15]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_7, &__v_15)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_23: G = __b2_out[0]; + let __v_16: G = if unconstrained { Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; let __ret: [G; OUT_331] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -30886,7 +30753,7 @@ fn aiur_fn_332( }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = result.output.try_into().unwrap(); __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -30895,7 +30762,7 @@ fn aiur_fn_332( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = result.output.try_into().unwrap(); __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_332] = [__v_32]; @@ -30963,7 +30830,7 @@ fn aiur_fn_333( }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = result.output.try_into().unwrap(); __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -30972,7 +30839,7 @@ fn aiur_fn_333( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = result.output.try_into().unwrap(); __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_333] = [__v_32]; @@ -31040,7 +30907,7 @@ fn aiur_fn_334( }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = result.output.try_into().unwrap(); __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -31049,7 +30916,7 @@ fn aiur_fn_334( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = result.output.try_into().unwrap(); __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_334] = [__v_32]; @@ -31093,9 +30960,9 @@ fn aiur_fn_335( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_335] = [__v_16]; record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31128,9 +30995,9 @@ fn aiur_fn_336( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = result.output.try_into().unwrap(); __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_16]; record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31164,7 +31031,7 @@ fn aiur_fn_337( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -31176,7 +31043,7 @@ fn aiur_fn_337( 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_337] = [__v_9, __v_10]; @@ -31232,11 +31099,11 @@ fn aiur_fn_338( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(1); @@ -31279,23 +31146,23 @@ fn aiur_fn_339( 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_9, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = result.output.try_into().unwrap(); __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_339] = [__v_14]; record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31369,11 +31236,11 @@ fn aiur_fn_340( } }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -31400,7 +31267,7 @@ fn aiur_fn_340( } }, 3u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = result.output.try_into().unwrap(); __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_340] = [__v_6, __v_7]; @@ -31440,21 +31307,21 @@ fn aiur_fn_341( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_341] = [__v_12, __v_13]; record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31530,177 +31397,177 @@ fn aiur_fn_343( ) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_59]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_71]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_75]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = (__v_84 + __v_86); let __v_88: G = (__v_82 + __v_87); @@ -31765,15 +31632,15 @@ fn aiur_fn_344( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = result.output.try_into().unwrap(); __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -31792,24 +31659,24 @@ fn aiur_fn_344( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_19, __v_22]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31850,24 +31717,24 @@ fn aiur_fn_344( }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_19, __v_22]; record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -31891,7 +31758,7 @@ fn aiur_fn_344( } }, 0u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = result.output.try_into().unwrap(); __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_344] = [__v_10, __v_11]; @@ -31941,35 +31808,35 @@ fn aiur_fn_345( }, 0u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_15, __v_17, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = result.output.try_into().unwrap(); __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_15, __v_17, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { 1u64 => { let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_22, __v_23]; record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32035,248 +31902,248 @@ fn aiur_fn_346( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_6, __v_9]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = result.output.try_into().unwrap(); __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_8, __v_11]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = result.output.try_into().unwrap(); __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = result.output.try_into().unwrap(); __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_10, __v_13]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = result.output.try_into().unwrap(); __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_12, __v_15]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_14, __v_17]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = result.output.try_into().unwrap(); __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = result.output.try_into().unwrap(); __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_16, __v_19]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = result.output.try_into().unwrap(); __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_18, __v_21]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = result.output.try_into().unwrap(); __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = result.output.try_into().unwrap(); __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_20, __v_23]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = result.output.try_into().unwrap(); __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = result.output.try_into().unwrap(); __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_22, __v_25]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = result.output.try_into().unwrap(); __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = result.output.try_into().unwrap(); __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_24, __v_27]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = result.output.try_into().unwrap(); __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = result.output.try_into().unwrap(); __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_26, __v_29]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = result.output.try_into().unwrap(); __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = result.output.try_into().unwrap(); __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_28, __v_31]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = result.output.try_into().unwrap(); __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { 1u64 => { let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_31, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_31, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_30, __v_32]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = result.output.try_into().unwrap(); __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; match __v_31.as_canonical_u64() { 1u64 => { let __v_32: G = G::from_u64(1); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_33, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_33, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_32, __v_34]; record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32378,12 +32245,12 @@ fn aiur_fn_347( let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -32391,7 +32258,7 @@ fn aiur_fn_347( }; let __v_2: G = __mc_out___mc_0[0]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -32515,7 +32382,7 @@ fn aiur_fn_349( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -32532,14 +32399,14 @@ fn aiur_fn_349( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = result.output.try_into().unwrap(); __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -32555,9 +32422,9 @@ fn aiur_fn_349( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_15, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -32572,9 +32439,9 @@ fn aiur_fn_349( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { @@ -32602,12 +32469,12 @@ fn aiur_fn_349( let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 10] = [__v_30, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 10] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_33, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = result.output.try_into().unwrap(); __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_33, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_17, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = result.output.try_into().unwrap(); __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_17, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_349] = [__v_36, __v_37]; record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32647,7 +32514,7 @@ fn aiur_fn_350( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -32657,15 +32524,15 @@ fn aiur_fn_350( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = result.output.try_into().unwrap(); __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); let __v_13: G = (__v_11 - __v_12); @@ -32673,10 +32540,10 @@ fn aiur_fn_350( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_350] = [__v_14, __v_16, __v_18]; record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32732,7 +32599,7 @@ fn aiur_fn_350( let __v_41: G = G::from_u64(148); let __v_42: G = G::from_u64(210); let __v_43: G = { let __values: [G; 32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 0u64 => { @@ -32750,7 +32617,7 @@ fn aiur_fn_350( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(2); let __v_47: G = { let __a_val = __v_45.as_canonical_u64(); let __b_val = __v_46.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -32771,9 +32638,9 @@ fn aiur_fn_350( }, 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -32783,11 +32650,11 @@ fn aiur_fn_350( let __v_55: G = __loaded[3]; match __v_52.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_56, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; match __v_58.as_canonical_u64() { 0u64 => { @@ -32805,7 +32672,7 @@ fn aiur_fn_350( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(1); let __v_61: G = (__v_59 - __v_60); @@ -32813,10 +32680,10 @@ fn aiur_fn_350( 0u64 => { let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_51, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_51, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __ret: [G; OUT_350] = [__v_62, __v_64, __v_66]; record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -32906,7 +32773,7 @@ fn aiur_fn_351( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(3); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -32923,18 +32790,18 @@ fn aiur_fn_351( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = result.output.try_into().unwrap(); __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_12, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = result.output.try_into().unwrap(); __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_12, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -32962,11 +32829,11 @@ fn aiur_fn_351( }, 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_19, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = result.output.try_into().unwrap(); __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_351] = [__v_20, __v_21]; record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -33011,7 +32878,7 @@ fn aiur_fn_352( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_1, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_5, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = result.output.try_into().unwrap(); __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -33083,13 +32950,13 @@ fn aiur_fn_353( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = result.output.try_into().unwrap(); __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = result.output.try_into().unwrap(); __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_353] = [__v_7, __v_8]; @@ -33097,13 +32964,13 @@ fn aiur_fn_353( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = result.output.try_into().unwrap(); __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = result.output.try_into().unwrap(); __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_353] = [__v_9, __v_10]; @@ -33111,13 +32978,13 @@ fn aiur_fn_353( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = result.output.try_into().unwrap(); __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = result.output.try_into().unwrap(); __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_353] = [__v_11, __v_12]; @@ -33165,7 +33032,7 @@ fn aiur_fn_354( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33182,9 +33049,9 @@ fn aiur_fn_354( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -33194,11 +33061,11 @@ fn aiur_fn_354( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = result.output.try_into().unwrap(); __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 0u64 => { @@ -33212,7 +33079,7 @@ fn aiur_fn_354( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(4); let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33229,9 +33096,9 @@ fn aiur_fn_354( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -33241,11 +33108,11 @@ fn aiur_fn_354( let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = result.output.try_into().unwrap(); __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; match __v_31.as_canonical_u64() { 0u64 => { @@ -33259,7 +33126,7 @@ fn aiur_fn_354( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33276,13 +33143,13 @@ fn aiur_fn_354( }, 0u64 => { let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_24, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -33293,7 +33160,7 @@ fn aiur_fn_354( let __v_47: G = { let __values: [G; 3] = [__v_43, __v_40, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = { let __values: [G; 3] = [__v_42, __v_38, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = { let __values: [G; 3] = [__v_41, __v_36, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = result.output.try_into().unwrap(); __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __ret: [G; OUT_354] = [__v_50, __v_51]; @@ -33366,27 +33233,27 @@ fn aiur_fn_355( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = result.output.try_into().unwrap(); __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = result.output.try_into().unwrap(); __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_355] = [__v_7, __v_8]; record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = result.output.try_into().unwrap(); __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = result.output.try_into().unwrap(); __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_355] = [__v_9, __v_10]; @@ -33394,13 +33261,13 @@ fn aiur_fn_355( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = result.output.try_into().unwrap(); __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = result.output.try_into().unwrap(); __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_355] = [__v_11, __v_12]; @@ -33408,27 +33275,27 @@ fn aiur_fn_355( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = result.output.try_into().unwrap(); __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = result.output.try_into().unwrap(); __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_355] = [__v_13, __v_14]; record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = result.output.try_into().unwrap(); __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = result.output.try_into().unwrap(); __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_14 + __v_16); match __v_17.as_canonical_u64() { @@ -33443,7 +33310,7 @@ fn aiur_fn_355( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33460,13 +33327,13 @@ fn aiur_fn_355( }, 0u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = result.output.try_into().unwrap(); __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_355] = [__v_24, __v_25]; @@ -33474,7 +33341,7 @@ fn aiur_fn_355( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = result.output.try_into().unwrap(); __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_355] = [__v_24, __v_25]; @@ -33593,7 +33460,7 @@ fn aiur_fn_358( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(3); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33610,9 +33477,9 @@ fn aiur_fn_358( }, 0u64 => { let __v_5: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -33622,16 +33489,16 @@ fn aiur_fn_358( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = result.output.try_into().unwrap(); __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = result.output.try_into().unwrap(); __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_358] = [__v_16, __v_17]; record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -33683,7 +33550,7 @@ fn aiur_fn_359( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33700,9 +33567,9 @@ fn aiur_fn_359( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -33712,15 +33579,15 @@ fn aiur_fn_359( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = result.output.try_into().unwrap(); __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = result.output.try_into().unwrap(); __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_15 + __v_17); match __v_18.as_canonical_u64() { @@ -33736,7 +33603,7 @@ fn aiur_fn_359( }, _ => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = result.output.try_into().unwrap(); __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_359] = [__v_19, __v_20]; record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -33782,15 +33649,15 @@ fn aiur_fn_360( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_8 + __v_10); match __v_11.as_canonical_u64() { @@ -33894,35 +33761,35 @@ fn aiur_fn_362( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = result.output.try_into().unwrap(); __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = result.output.try_into().unwrap(); __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = result.output.try_into().unwrap(); __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = result.output.try_into().unwrap(); __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = result.output.try_into().unwrap(); __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_16 + __v_18); let __v_20: G = (__v_14 + __v_19); match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = result.output.try_into().unwrap(); __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_362] = [__v_21, __v_22]; @@ -33944,7 +33811,7 @@ fn aiur_fn_362( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(2); let __v_25: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_24.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33960,7 +33827,7 @@ fn aiur_fn_362( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = result.output.try_into().unwrap(); __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_362] = [__v_26, __v_27]; @@ -34004,15 +33871,15 @@ fn aiur_fn_363( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_12 + __v_14); match __v_15.as_canonical_u64() { @@ -34108,12 +33975,12 @@ fn aiur_fn_364( let __v_2: G = inp[2]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = result.output.try_into().unwrap(); __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = result.output.try_into().unwrap(); __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; break '__mc_0 [__v_3]; }, @@ -34121,7 +33988,7 @@ fn aiur_fn_364( }; let __v_3: G = __mc_out___mc_0[0]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -34134,7 +34001,7 @@ fn aiur_fn_364( let __v_12: G = { let __values: [G; 4] = [__v_7, __v_6, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -34175,7 +34042,7 @@ fn aiur_fn_365( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(2); let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34192,18 +34059,18 @@ fn aiur_fn_365( }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_10, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -34219,7 +34086,7 @@ fn aiur_fn_365( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = result.output.try_into().unwrap(); __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_365] = [__v_19, __v_20]; @@ -34229,7 +34096,7 @@ fn aiur_fn_365( } }, _ => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = result.output.try_into().unwrap(); __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_365] = [__v_16, __v_17]; @@ -34263,28 +34130,28 @@ fn aiur_fn_366( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_9, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = result.output.try_into().unwrap(); __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_9, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_12, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = result.output.try_into().unwrap(); __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_15, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = result.output.try_into().unwrap(); __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; match __v_18.as_canonical_u64() { @@ -34299,10 +34166,10 @@ fn aiur_fn_366( let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_29: G = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_28, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_28, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_31, __v_32]; record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -34380,14 +34247,14 @@ fn aiur_fn_367( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -34402,9 +34269,9 @@ fn aiur_fn_367( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(2); let __v_19: G = G::from_u64(0); @@ -34413,10 +34280,10 @@ fn aiur_fn_367( let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_18, __v_19, __v_22, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = result.output.try_into().unwrap(); __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_25, __v_8, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_25, __v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { @@ -34444,9 +34311,9 @@ fn aiur_fn_367( let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_40, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); let __ret: [G; OUT_367] = [__v_44, __v_43]; @@ -34464,7 +34331,7 @@ fn aiur_fn_367( } }, 0u64 => { - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = result.output.try_into().unwrap(); __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_367] = [__v_9, __v_10]; @@ -34497,19 +34364,19 @@ fn aiur_fn_368( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_11, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_11, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -34538,12 +34405,12 @@ fn aiur_fn_368( 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_15, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = result.output.try_into().unwrap(); __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, 0u64 => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, @@ -34553,7 +34420,7 @@ fn aiur_fn_368( } }; let __v_18: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_18, __v_9, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = result.output.try_into().unwrap(); __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_18, __v_9, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_368] = [__v_19, __v_20]; @@ -34593,10 +34460,10 @@ fn aiur_fn_369( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -34611,10 +34478,10 @@ fn aiur_fn_369( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = result.output.try_into().unwrap(); __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_15, __v_10, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_15, __v_10, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; match __v_17.as_canonical_u64() { @@ -34631,19 +34498,19 @@ fn aiur_fn_369( 1u64 => { let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = result.output.try_into().unwrap(); __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; break '__mc_0 [__v_21, __v_22]; }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = result.output.try_into().unwrap(); __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; break '__mc_0 [__v_21, __v_22]; @@ -34703,12 +34570,12 @@ fn aiur_fn_369( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = result.output.try_into().unwrap(); __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; break '__mc_1 [__v_53]; }, 0u64 => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = result.output.try_into().unwrap(); __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; break '__mc_1 [__v_53]; }, @@ -34720,12 +34587,12 @@ fn aiur_fn_369( 0u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = result.output.try_into().unwrap(); __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; break '__mc_1 [__v_53]; }, 0u64 => { - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = result.output.try_into().unwrap(); __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; break '__mc_1 [__v_53]; }, @@ -34741,7 +34608,7 @@ fn aiur_fn_369( }; let __v_53: G = __mc_out___mc_1[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_53, __v_10, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_53, __v_10, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; match __v_55.as_canonical_u64() { @@ -34786,7 +34653,7 @@ fn aiur_fn_369( let __v_72: G = G::from_u64(3); let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_52, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_2, __v_74, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = result.output.try_into().unwrap(); __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_2, __v_74, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __ret: [G; OUT_369] = [__v_75, __v_76]; @@ -34840,12 +34707,12 @@ fn aiur_fn_370( let __v_7: G = inp[7]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = result.output.try_into().unwrap(); __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, 0u64 => { - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = result.output.try_into().unwrap(); __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -34856,7 +34723,7 @@ fn aiur_fn_370( }; let __v_8: G = __mc_out___mc_0[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -34875,18 +34742,18 @@ fn aiur_fn_370( let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_14, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_18, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_18, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = { let __a_val = __v_22.as_canonical_u64(); let __b_val = __v_23.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34903,7 +34770,7 @@ fn aiur_fn_370( }, 0u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_21, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); let __v_28: G = G::from_u64(1); @@ -34918,10 +34785,10 @@ fn aiur_fn_370( let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = G::from_u64(2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_38, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_38, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_41, __v_42]; record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -34952,7 +34819,7 @@ fn aiur_fn_371( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34969,7 +34836,7 @@ fn aiur_fn_371( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -34980,13 +34847,13 @@ fn aiur_fn_371( 7u64 => { match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = result.output.try_into().unwrap(); __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -35010,13 +34877,13 @@ fn aiur_fn_371( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = result.output.try_into().unwrap(); __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = result.output.try_into().unwrap(); __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_371] = [__v_16, __v_17]; @@ -35024,13 +34891,13 @@ fn aiur_fn_371( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = result.output.try_into().unwrap(); __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = result.output.try_into().unwrap(); __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_17 + __v_19); match __v_20.as_canonical_u64() { @@ -35045,7 +34912,7 @@ fn aiur_fn_371( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = result.output.try_into().unwrap(); __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_371] = [__v_21, __v_22]; @@ -35113,10 +34980,10 @@ fn aiur_fn_372( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = result.output.try_into().unwrap(); __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -35173,10 +35040,10 @@ fn aiur_fn_373( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -35191,9 +35058,9 @@ fn aiur_fn_373( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = result.output.try_into().unwrap(); __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = result.output.try_into().unwrap(); __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); @@ -35232,19 +35099,19 @@ fn aiur_fn_374( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = result.output.try_into().unwrap(); __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_374] = [__v_2, __v_5, __v_8, __v_11]; @@ -35264,23 +35131,19 @@ fn aiur_fn_375( ) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = result.output.try_into().unwrap(); __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_1, __v_5]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_1, &__v_5)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_6: G = __b2_out[0]; + let __v_6: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; let __v_7: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_2, __v_7]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_2, &__v_7)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_8: G = __b2_out[0]; + let __v_8: G = if unconstrained { Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record) }; let __v_9: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_3, __v_9]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_3, &__v_9)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_10: G = __b2_out[0]; + let __v_10: G = if unconstrained { Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record) }; let __v_11: G = G::from_u64(0); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_4, __v_11]; if unconstrained { __scratch.extend(vec![Bytes2::xor(&__v_4, &__v_11)]); } else { bytes2_execute(0, 1, &Bytes2Op::Xor, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_12: G = __b2_out[0]; + let __v_12: G = if unconstrained { Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record) }; let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_8); let __v_15: G = G::from_u64(65536); @@ -35320,7 +35183,7 @@ fn aiur_fn_376( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = result.output.try_into().unwrap(); __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_376] = [__v_2]; record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -35351,10 +35214,10 @@ fn aiur_fn_377( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = result.output.try_into().unwrap(); __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = result.output.try_into().unwrap(); __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_377] = [__v_7]; record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -35380,8 +35243,7 @@ fn aiur_fn_378( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(128); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_2]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_2)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_3: G = __b2_out[0]; + let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_378] = [__v_0, __v_1]; @@ -35390,8 +35252,7 @@ fn aiur_fn_378( }, 0u64 => { let __v_4: G = G::from_u64(224); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_4]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_4)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_5: G = __b2_out[0]; + let __v_5: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record) }; match __v_5.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -35418,8 +35279,7 @@ fn aiur_fn_378( }, 0u64 => { let __v_6: G = G::from_u64(240); - let __b2_out: [G; 1] = { let mut __scratch: Vec = vec![__v_0, __v_6]; if unconstrained { __scratch.extend(vec![Bytes2::less_than(&__v_0, &__v_6)]); } else { bytes2_execute(0, 1, &Bytes2Op::LessThan, &mut __scratch, record); } let __arr: [G; 1] = __scratch[2..].try_into().unwrap(); __arr }; - let __v_7: G = __b2_out[0]; + let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) }; match __v_7.as_canonical_u64() { 1u64 => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -35544,10 +35404,10 @@ fn aiur_fn_379( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = result.output.try_into().unwrap(); __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -35562,10 +35422,10 @@ fn aiur_fn_379( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = result.output.try_into().unwrap(); __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -35580,10 +35440,10 @@ fn aiur_fn_379( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = result.output.try_into().unwrap(); __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -35598,10 +35458,10 @@ fn aiur_fn_379( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = result.output.try_into().unwrap(); __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_14, __v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_14, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -35616,10 +35476,10 @@ fn aiur_fn_379( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = result.output.try_into().unwrap(); __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_18, __v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_18, __v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { @@ -35672,7 +35532,7 @@ fn aiur_fn_379( let __v_57: G = G::from_u64(3); let __v_58: G = G::from_u64(0); let __v_59: G = { let __values: [G; 4] = [__v_57, __v_35, __v_41, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_56, __v_59, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = result.output.try_into().unwrap(); __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_56, __v_59, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(1); let __v_62: G = G::from_u64(3); @@ -35734,10 +35594,10 @@ fn aiur_fn_380( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = result.output.try_into().unwrap(); __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = result.output.try_into().unwrap(); __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -35749,7 +35609,7 @@ fn aiur_fn_380( let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = result.output.try_into().unwrap(); __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); @@ -35786,7 +35646,7 @@ fn aiur_fn_381( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = result.output.try_into().unwrap(); __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { @@ -35834,7 +35694,7 @@ fn aiur_fn_382( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -35851,7 +35711,7 @@ fn aiur_fn_382( match __v_4.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = result.output.try_into().unwrap(); __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -35859,7 +35719,7 @@ fn aiur_fn_382( let __v_20: G = __r_arr[4]; match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_22.as_canonical_u64() { @@ -35874,14 +35734,14 @@ fn aiur_fn_382( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(8); let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_27, __v_28]; record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -35933,11 +35793,11 @@ fn aiur_fn_383( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = result.output.try_into().unwrap(); __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -35960,11 +35820,11 @@ fn aiur_fn_383( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = result.output.try_into().unwrap(); __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -35978,7 +35838,7 @@ fn aiur_fn_383( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(5); let __v_17: G = { let __a_val = __v_15.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35995,19 +35855,19 @@ fn aiur_fn_383( }, 0u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(4); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -36040,10 +35900,10 @@ fn aiur_fn_383( let __v_47: G = G::from_u64(4); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 4] = [__v_47, __v_42, __v_46, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_50, __v_4, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_50, __v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; match __v_52.as_canonical_u64() { @@ -36076,10 +35936,10 @@ fn aiur_fn_383( let __v_79: G = G::from_u64(0); let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_81: G = G::from_u64(5); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_81]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_80, __v_82]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_80, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __ret: [G; OUT_383] = [__v_83, __v_84]; record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36198,7 +36058,7 @@ fn aiur_fn_384( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = result.output.try_into().unwrap(); __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -36308,51 +36168,51 @@ fn aiur_fn_385( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_7]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_8]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_8]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = result.output.try_into().unwrap(); __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_5]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_5]; record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36378,17 +36238,17 @@ fn aiur_fn_386( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = result.output.try_into().unwrap(); __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_386] = [__v_8]; record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36499,11 +36359,11 @@ fn aiur_fn_390( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = result.output.try_into().unwrap(); __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = result.output.try_into().unwrap(); __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_4]; record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36525,14 +36385,14 @@ fn aiur_fn_391( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = result.output.try_into().unwrap(); __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = result.output.try_into().unwrap(); __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = result.output.try_into().unwrap(); __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_391] = [__v_7]; record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36574,16 +36434,16 @@ fn aiur_fn_392( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = result.output.try_into().unwrap(); __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_392] = [__v_13]; record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36618,7 +36478,7 @@ fn aiur_fn_393( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { @@ -36628,9 +36488,9 @@ fn aiur_fn_393( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = result.output.try_into().unwrap(); __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_5]; record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36665,7 +36525,7 @@ fn aiur_fn_394( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_4.as_canonical_u64() { @@ -36675,7 +36535,7 @@ fn aiur_fn_394( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = result.output.try_into().unwrap(); __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_5]; record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36749,9 +36609,9 @@ fn aiur_fn_395( }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36761,11 +36621,11 @@ fn aiur_fn_395( }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36775,11 +36635,11 @@ fn aiur_fn_395( }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36789,13 +36649,13 @@ fn aiur_fn_395( }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_13]; @@ -36812,7 +36672,7 @@ fn aiur_fn_395( }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_395] = [__v_9]; @@ -36839,7 +36699,7 @@ fn aiur_fn_396( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_4.as_canonical_u64() { @@ -36849,7 +36709,7 @@ fn aiur_fn_396( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = result.output.try_into().unwrap(); __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_396] = [__v_5]; record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36894,7 +36754,7 @@ fn aiur_fn_397( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_397] = [__v_10]; record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -36935,9 +36795,9 @@ fn aiur_fn_397( }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36947,11 +36807,11 @@ fn aiur_fn_397( }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36961,11 +36821,11 @@ fn aiur_fn_397( }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -36975,13 +36835,13 @@ fn aiur_fn_397( }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_397] = [__v_13]; @@ -36998,7 +36858,7 @@ fn aiur_fn_397( }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_397] = [__v_9]; @@ -37025,7 +36885,7 @@ fn aiur_fn_398( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_4.as_canonical_u64() { @@ -37035,7 +36895,7 @@ fn aiur_fn_398( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = result.output.try_into().unwrap(); __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_398] = [__v_5]; record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37072,17 +36932,17 @@ fn aiur_fn_399( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_2 + __v_4); let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_10]; record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37129,7 +36989,7 @@ fn aiur_fn_400( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = result.output.try_into().unwrap(); __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_7]; record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37153,9 +37013,9 @@ fn aiur_fn_400( }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -37165,11 +37025,11 @@ fn aiur_fn_400( }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -37179,11 +37039,11 @@ fn aiur_fn_400( }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -37193,13 +37053,13 @@ fn aiur_fn_400( }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_400] = [__v_13]; @@ -37216,7 +37076,7 @@ fn aiur_fn_400( }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_400] = [__v_9]; @@ -37256,7 +37116,7 @@ fn aiur_fn_401( let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_8]; record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37297,7 +37157,7 @@ fn aiur_fn_402( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_9, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -37342,15 +37202,15 @@ fn aiur_fn_403( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_12]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37358,12 +37218,12 @@ fn aiur_fn_403( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_16]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37371,9 +37231,9 @@ fn aiur_fn_403( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_403] = [__v_14]; record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37405,26 +37265,26 @@ fn aiur_fn_404( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_12]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = result.output.try_into().unwrap(); __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = result.output.try_into().unwrap(); __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37432,23 +37292,23 @@ fn aiur_fn_404( }, 6u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_11]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = result.output.try_into().unwrap(); __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_9]; record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37475,17 +37335,17 @@ fn aiur_fn_405( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = result.output.try_into().unwrap(); __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_12]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37499,7 +37359,7 @@ fn aiur_fn_405( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -37516,9 +37376,9 @@ fn aiur_fn_405( match __v_17.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_30]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37527,7 +37387,7 @@ fn aiur_fn_405( _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_30]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37538,7 +37398,7 @@ fn aiur_fn_405( _ => { let __v_16: G = G::from_u64(8); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_405] = [__v_18]; record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37575,19 +37435,19 @@ fn aiur_fn_406( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = result.output.try_into().unwrap(); __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = result.output.try_into().unwrap(); __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_13 + __v_15); let __v_17: G = (__v_11 + __v_16); @@ -37603,21 +37463,21 @@ fn aiur_fn_406( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_23, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_23, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; match __v_25.as_canonical_u64() { @@ -37632,17 +37492,17 @@ fn aiur_fn_406( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = result.output.try_into().unwrap(); __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_16 * __v_29); let __v_31: G = (__v_27 + __v_30); match __v_31.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { @@ -37662,7 +37522,7 @@ fn aiur_fn_406( let __v_36: G = G::from_u64(3); let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 4] = [__v_36, __v_0, __v_21, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_35, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -37737,7 +37597,7 @@ fn aiur_fn_407( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = result.output.try_into().unwrap(); __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -37748,7 +37608,7 @@ fn aiur_fn_407( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = result.output.try_into().unwrap(); __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { @@ -37759,7 +37619,7 @@ fn aiur_fn_407( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = result.output.try_into().unwrap(); __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { @@ -37770,7 +37630,7 @@ fn aiur_fn_407( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = result.output.try_into().unwrap(); __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -37781,7 +37641,7 @@ fn aiur_fn_407( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = result.output.try_into().unwrap(); __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -37845,9 +37705,9 @@ fn aiur_fn_408( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -37863,19 +37723,19 @@ fn aiur_fn_408( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = result.output.try_into().unwrap(); __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_22]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_22]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37887,19 +37747,19 @@ fn aiur_fn_408( } }, 4u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = result.output.try_into().unwrap(); __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_22]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_22]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37911,11 +37771,11 @@ fn aiur_fn_408( } }, _ => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = result.output.try_into().unwrap(); __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = result.output.try_into().unwrap(); __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; break '__mc_0 [__v_21, __v_22]; @@ -37934,19 +37794,19 @@ fn aiur_fn_408( let __v_22: G = __mc_out___mc_0[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_23]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = result.output.try_into().unwrap(); __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_25]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37955,7 +37815,7 @@ fn aiur_fn_408( 0u64 => { match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = result.output.try_into().unwrap(); __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; match __v_25.as_canonical_u64() { @@ -37965,9 +37825,9 @@ fn aiur_fn_408( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_27, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_27, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_28]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -37979,14 +37839,14 @@ fn aiur_fn_408( } }, 2u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_25]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_25]; record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38054,11 +37914,11 @@ fn aiur_fn_409( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = result.output.try_into().unwrap(); __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_409] = [__v_10]; record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38082,10 +37942,10 @@ fn aiur_fn_410( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_410] = [__v_6]; record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38115,26 +37975,26 @@ fn aiur_fn_411( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_12]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = result.output.try_into().unwrap(); __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_9]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = result.output.try_into().unwrap(); __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_9]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38142,23 +38002,23 @@ fn aiur_fn_411( }, 6u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_11]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = result.output.try_into().unwrap(); __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_9]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_9]; record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38186,15 +38046,15 @@ fn aiur_fn_412( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = result.output.try_into().unwrap(); __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_12]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38202,12 +38062,12 @@ fn aiur_fn_412( }, 1u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_16]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38215,9 +38075,9 @@ fn aiur_fn_412( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_14]; record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38244,17 +38104,17 @@ fn aiur_fn_413( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = result.output.try_into().unwrap(); __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_12]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38268,7 +38128,7 @@ fn aiur_fn_413( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38285,9 +38145,9 @@ fn aiur_fn_413( match __v_17.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = result.output.try_into().unwrap(); __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_30]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38296,7 +38156,7 @@ fn aiur_fn_413( _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_30]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38307,7 +38167,7 @@ fn aiur_fn_413( _ => { let __v_16: G = G::from_u64(8); let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_18]; record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38339,9 +38199,9 @@ fn aiur_fn_414( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38357,19 +38217,19 @@ fn aiur_fn_414( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = result.output.try_into().unwrap(); __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_22]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_22]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38381,19 +38241,19 @@ fn aiur_fn_414( } }, 4u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = result.output.try_into().unwrap(); __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_22]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_22]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38405,11 +38265,11 @@ fn aiur_fn_414( } }, _ => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = result.output.try_into().unwrap(); __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = result.output.try_into().unwrap(); __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; break '__mc_0 [__v_21, __v_22]; @@ -38428,26 +38288,26 @@ fn aiur_fn_414( let __v_22: G = __mc_out___mc_0[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_23]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = result.output.try_into().unwrap(); __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_25]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_25]; record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38513,11 +38373,11 @@ fn aiur_fn_415( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = result.output.try_into().unwrap(); __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_10]; record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38541,10 +38401,10 @@ fn aiur_fn_416( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = result.output.try_into().unwrap(); __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_416] = [__v_6]; record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38577,7 +38437,7 @@ fn aiur_fn_417( let __v_12: G = (__v_6 + __v_4); let __v_13: G = (__v_5 + __v_12); let __v_14: G = (__v_3 + __v_13); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_16.as_canonical_u64() { @@ -38592,12 +38452,12 @@ fn aiur_fn_417( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 - __v_2); match __v_18.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_1, __v_3, __v_5, __v_6, __v_14, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = result.output.try_into().unwrap(); __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_1, __v_3, __v_5, __v_6, __v_14, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_417] = [__v_19, __v_20]; @@ -38647,7 +38507,7 @@ fn aiur_fn_418( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38657,15 +38517,15 @@ fn aiur_fn_418( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = result.output.try_into().unwrap(); __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -38674,7 +38534,7 @@ fn aiur_fn_418( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_13, __v_15, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = result.output.try_into().unwrap(); __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_13, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_17]; record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -38723,11 +38583,11 @@ fn aiur_fn_419( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -38740,17 +38600,17 @@ fn aiur_fn_419( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(2); let __v_12: G = (__v_10 - __v_11); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38830,10 +38690,10 @@ fn aiur_fn_420( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -38859,9 +38719,9 @@ fn aiur_fn_420( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 10] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = result.output.try_into().unwrap(); __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -38869,7 +38729,7 @@ fn aiur_fn_420( let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -38881,10 +38741,10 @@ fn aiur_fn_420( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_29, __v_2, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_29, __v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { @@ -38958,7 +38818,7 @@ fn aiur_fn_421( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = result.output.try_into().unwrap(); __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { @@ -38969,11 +38829,11 @@ fn aiur_fn_421( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = result.output.try_into().unwrap(); __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -38997,17 +38857,17 @@ fn aiur_fn_421( } }; let __v_14: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = result.output.try_into().unwrap(); __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_15, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_15, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_16, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = result.output.try_into().unwrap(); __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_16, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_17, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = result.output.try_into().unwrap(); __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_17, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_18, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = result.output.try_into().unwrap(); __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_18, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39017,7 +38877,7 @@ fn aiur_fn_421( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -39033,7 +38893,7 @@ fn aiur_fn_421( let __v_37: G = __loaded[10]; match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_39.as_canonical_u64() { @@ -39048,7 +38908,7 @@ fn aiur_fn_421( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __a_val = __v_40.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_41.as_canonical_u64() { @@ -39063,7 +38923,7 @@ fn aiur_fn_421( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_6, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = result.output.try_into().unwrap(); __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __v_44: G = __r_arr[2]; @@ -39071,22 +38931,22 @@ fn aiur_fn_421( _ => { let __v_45: G = (__v_3 + __v_4); let __v_46: G = (__v_2 + __v_45); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_1, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = (__v_40 - __v_33); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_21, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_5 + __v_50); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_44, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_44, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_53, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_53, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_54, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_54, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __ret: [G; OUT_421] = [__v_57, __v_56]; @@ -39106,7 +38966,7 @@ fn aiur_fn_421( } }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = result.output.try_into().unwrap(); __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __ret: [G; OUT_421] = [__v_38, __v_39]; @@ -39116,7 +38976,7 @@ fn aiur_fn_421( } }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = result.output.try_into().unwrap(); __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_421] = [__v_26, __v_27]; @@ -39164,11 +39024,11 @@ fn aiur_fn_422( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_11, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_11, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -39186,11 +39046,11 @@ fn aiur_fn_422( let __v_14: G = (__v_1 + __v_2); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 + __v_15); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_18, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = result.output.try_into().unwrap(); __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 0u64 => { @@ -39204,35 +39064,35 @@ fn aiur_fn_422( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = result.output.try_into().unwrap(); __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_28, __v_29]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_28, __v_7, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = result.output.try_into().unwrap(); __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_28, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; match __v_30.as_canonical_u64() { @@ -39257,12 +39117,12 @@ fn aiur_fn_422( let __v_39: G = G::from_u64(3); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_39, __v_37, __v_21, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_38, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_45, __v_46]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39280,11 +39140,11 @@ fn aiur_fn_422( }, 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_26, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_27, __v_30]; record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39338,7 +39198,7 @@ fn aiur_fn_423( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39348,11 +39208,11 @@ fn aiur_fn_423( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -39362,14 +39222,14 @@ fn aiur_fn_423( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_19 - __v_20); match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39450,18 +39310,18 @@ fn aiur_fn_424( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = result.output.try_into().unwrap(); __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -39477,7 +39337,7 @@ fn aiur_fn_424( let __v_26: G = __loaded[10]; match __v_16.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -39493,7 +39353,7 @@ fn aiur_fn_424( let __v_38: G = __loaded[10]; match __v_28.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -39501,11 +39361,11 @@ fn aiur_fn_424( 0u64 => { match __v_34.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_41, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = result.output.try_into().unwrap(); __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_41, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; match __v_42.as_canonical_u64() { 1u64 => { @@ -39519,22 +39379,22 @@ fn aiur_fn_424( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_14, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = (__v_1 + __v_2); let __v_45: G = (__v_44 + __v_3); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_43, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_47, __v_19, __v_40, __v_13, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = result.output.try_into().unwrap(); __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_47, __v_19, __v_40, __v_13, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_4 + __v_50); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __ret: [G; OUT_424] = [__v_54, __v_53]; @@ -39625,7 +39485,7 @@ fn aiur_fn_425( let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = result.output.try_into().unwrap(); __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_425] = [__v_5, __v_6]; @@ -39633,7 +39493,7 @@ fn aiur_fn_425( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = result.output.try_into().unwrap(); __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_425] = [__v_5, __v_6]; @@ -39668,7 +39528,7 @@ fn aiur_fn_426( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(6); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -39685,23 +39545,23 @@ fn aiur_fn_426( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = result.output.try_into().unwrap(); __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __ret: [G; OUT_426] = [__v_19, __v_18]; @@ -39744,7 +39604,7 @@ fn aiur_fn_427( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(5); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -39761,23 +39621,23 @@ fn aiur_fn_427( }, 0u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(4); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = result.output.try_into().unwrap(); __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(3); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __ret: [G; OUT_427] = [__v_19, __v_18]; @@ -39820,9 +39680,9 @@ fn aiur_fn_428( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39832,7 +39692,7 @@ fn aiur_fn_428( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -39850,14 +39710,14 @@ fn aiur_fn_428( 4u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(3); let __v_25: G = (__v_23 - __v_24); match __v_25.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_u64(2); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __ret: [G; OUT_428] = [__v_28, __v_27]; @@ -39944,7 +39804,7 @@ fn aiur_fn_429( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = result.output.try_into().unwrap(); __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_13]; record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -39990,7 +39850,7 @@ fn aiur_fn_430( 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -40006,7 +39866,7 @@ fn aiur_fn_430( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -40022,7 +39882,7 @@ fn aiur_fn_430( let __v_34: G = __loaded[10]; match __v_24.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { @@ -40037,13 +39897,13 @@ fn aiur_fn_430( }, _ => { let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -40059,13 +39919,13 @@ fn aiur_fn_430( let __v_47: G = G::from_u64(2); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_41, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_51, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_51, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; match __v_53.as_canonical_u64() { 1u64 => { @@ -40170,7 +40030,7 @@ fn aiur_fn_431( _ => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = result.output.try_into().unwrap(); __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_431] = [__v_7]; record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40293,7 +40153,7 @@ fn aiur_fn_434( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_7]; record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40302,11 +40162,11 @@ fn aiur_fn_434( _ => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_10]; record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40335,11 +40195,11 @@ fn aiur_fn_435( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = result.output.try_into().unwrap(); __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_6]; record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40368,7 +40228,7 @@ fn aiur_fn_436( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_8]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40378,7 +40238,7 @@ fn aiur_fn_436( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -40390,7 +40250,7 @@ fn aiur_fn_436( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40404,42 +40264,42 @@ fn aiur_fn_436( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_23]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_14]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); @@ -40449,11 +40309,11 @@ fn aiur_fn_436( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -40464,7 +40324,7 @@ fn aiur_fn_436( let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -40476,13 +40336,13 @@ fn aiur_fn_436( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_11]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40491,14 +40351,14 @@ fn aiur_fn_436( 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = result.output.try_into().unwrap(); __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_8]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = result.output.try_into().unwrap(); __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_8]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40510,11 +40370,11 @@ fn aiur_fn_436( } }, 8u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -40527,7 +40387,7 @@ fn aiur_fn_436( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -40543,19 +40403,19 @@ fn aiur_fn_436( let __v_27: G = __loaded[10]; match __v_17.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); } let __v_30: G = (__v_20 + __v_21); - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = result.output.try_into().unwrap(); __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -40571,12 +40431,12 @@ fn aiur_fn_436( let __v_45: G = __loaded[10]; match __v_35.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_49]; record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40627,7 +40487,7 @@ fn aiur_fn_437( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_10]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40642,12 +40502,12 @@ fn aiur_fn_437( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_10, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_10, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_17]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40655,11 +40515,11 @@ fn aiur_fn_437( }, _ => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = result.output.try_into().unwrap(); __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = result.output.try_into().unwrap(); __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -40667,13 +40527,13 @@ fn aiur_fn_437( if (__v_16 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); } - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_17, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_17, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_20, __v_7, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = result.output.try_into().unwrap(); __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_25]; record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40702,7 +40562,7 @@ fn aiur_fn_438( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -40716,9 +40576,9 @@ fn aiur_fn_438( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = result.output.try_into().unwrap(); __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(1); @@ -40748,9 +40608,9 @@ fn aiur_fn_439( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = result.output.try_into().unwrap(); __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); if (__v_6 != __v_7) { @@ -40776,11 +40636,11 @@ fn aiur_fn_440( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = result.output.try_into().unwrap(); __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_6]; record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40809,7 +40669,7 @@ fn aiur_fn_441( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = result.output.try_into().unwrap(); __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_8]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40819,7 +40679,7 @@ fn aiur_fn_441( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = result.output.try_into().unwrap(); __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -40831,7 +40691,7 @@ fn aiur_fn_441( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40845,23 +40705,23 @@ fn aiur_fn_441( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_23]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -40871,16 +40731,16 @@ fn aiur_fn_441( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_6, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_14]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = result.output.try_into().unwrap(); __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -40889,7 +40749,7 @@ fn aiur_fn_441( return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); } let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_16, __v_6, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_19]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40900,7 +40760,7 @@ fn aiur_fn_441( 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); @@ -40910,11 +40770,11 @@ fn aiur_fn_441( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = result.output.try_into().unwrap(); __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = result.output.try_into().unwrap(); __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -40925,7 +40785,7 @@ fn aiur_fn_441( let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -40938,9 +40798,9 @@ fn aiur_fn_441( }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_10]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40949,14 +40809,14 @@ fn aiur_fn_441( 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = result.output.try_into().unwrap(); __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_8]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = result.output.try_into().unwrap(); __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_8]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -40968,11 +40828,11 @@ fn aiur_fn_441( } }, 8u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -40985,7 +40845,7 @@ fn aiur_fn_441( if (__v_13 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -41001,19 +40861,19 @@ fn aiur_fn_441( let __v_27: G = __loaded[10]; match __v_17.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); } let __v_30: G = (__v_20 + __v_21); - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = result.output.try_into().unwrap(); __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; @@ -41029,12 +40889,12 @@ fn aiur_fn_441( let __v_45: G = __loaded[10]; match __v_35.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_49]; record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41076,7 +40936,7 @@ fn aiur_fn_442( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -41090,9 +40950,9 @@ fn aiur_fn_442( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = result.output.try_into().unwrap(); __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(1); @@ -41279,11 +41139,11 @@ fn aiur_fn_445( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_8, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_11, __v_9, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = result.output.try_into().unwrap(); __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_14]; record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41332,21 +41192,21 @@ fn aiur_fn_446( let __v_13: G = (__v_1 - __v_2); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = result.output.try_into().unwrap(); __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_446] = [__v_10]; record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = result.output.try_into().unwrap(); __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_14: G = G::from_u64(8); let __v_15: G = { let __values: [G; 4] = [__v_14, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_2 + __v_18); - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_17, __v_1, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = result.output.try_into().unwrap(); __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_17, __v_1, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_20]; record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41384,7 +41244,7 @@ fn aiur_fn_447( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -41392,7 +41252,7 @@ fn aiur_fn_447( let __v_9: G = __loaded[2]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -41401,7 +41261,7 @@ fn aiur_fn_447( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { @@ -41434,14 +41294,14 @@ fn aiur_fn_448( let __v_4: G = inp[4]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_5]; record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -41452,7 +41312,7 @@ fn aiur_fn_448( 5u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_8, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = result.output.try_into().unwrap(); __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_8, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_12]; record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41485,9 +41345,9 @@ fn aiur_fn_449( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = result.output.try_into().unwrap(); __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41502,7 +41362,7 @@ fn aiur_fn_449( let __v_14: G = __loaded[2]; let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_17]; record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41540,7 +41400,7 @@ fn aiur_fn_450( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -41548,7 +41408,7 @@ fn aiur_fn_450( let __v_8: G = __loaded[2]; let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); if (__v_11 != __v_12) { @@ -41573,10 +41433,10 @@ fn aiur_fn_451( ) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = result.output.try_into().unwrap(); __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); @@ -41601,10 +41461,10 @@ fn aiur_fn_452( ) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = result.output.try_into().unwrap(); __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); @@ -41637,7 +41497,7 @@ fn aiur_fn_453( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -41648,7 +41508,7 @@ fn aiur_fn_453( 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_9]; record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41690,15 +41550,15 @@ fn aiur_fn_454( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = result.output.try_into().unwrap(); __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = result.output.try_into().unwrap(); __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = result.output.try_into().unwrap(); __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = result.output.try_into().unwrap(); __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_454] = [__v_10]; record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41723,7 +41583,7 @@ fn aiur_fn_455( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = result.output.try_into().unwrap(); __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -41733,7 +41593,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = result.output.try_into().unwrap(); __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -41743,9 +41603,9 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = result.output.try_into().unwrap(); __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); match __v_9.as_canonical_u64() { @@ -41756,7 +41616,7 @@ fn aiur_fn_455( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = result.output.try_into().unwrap(); __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -41766,7 +41626,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = result.output.try_into().unwrap(); __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -41776,9 +41636,9 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_12 - __v_13); match __v_14.as_canonical_u64() { @@ -41789,7 +41649,7 @@ fn aiur_fn_455( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = result.output.try_into().unwrap(); __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { @@ -41799,7 +41659,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = result.output.try_into().unwrap(); __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -41809,7 +41669,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = result.output.try_into().unwrap(); __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -41819,7 +41679,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_13, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = result.output.try_into().unwrap(); __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_13, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -41829,7 +41689,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = result.output.try_into().unwrap(); __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { @@ -41840,7 +41700,7 @@ fn aiur_fn_455( }, 0u64 => { let __v_21: G = G::from_u64(16); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -41850,7 +41710,7 @@ fn aiur_fn_455( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = result.output.try_into().unwrap(); __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_24]; record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41949,7 +41809,7 @@ fn aiur_fn_456( let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_19]; record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -41971,13 +41831,13 @@ fn aiur_fn_456( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_16]; record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42010,13 +41870,13 @@ fn aiur_fn_456( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_456] = [__v_16]; record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42066,9 +41926,9 @@ fn aiur_fn_457( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = result.output.try_into().unwrap(); __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { @@ -42078,9 +41938,9 @@ fn aiur_fn_457( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_457] = [__v_8]; record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42107,9 +41967,9 @@ fn aiur_fn_458( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -42162,11 +42022,11 @@ fn aiur_fn_459( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = result.output.try_into().unwrap(); __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -42176,9 +42036,9 @@ fn aiur_fn_459( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = result.output.try_into().unwrap(); __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_459] = [__v_9]; record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42203,7 +42063,7 @@ fn aiur_fn_460( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42213,7 +42073,7 @@ fn aiur_fn_460( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -42237,14 +42097,14 @@ fn aiur_fn_460( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -42329,7 +42189,7 @@ fn aiur_fn_461( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = result.output.try_into().unwrap(); __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -42339,7 +42199,7 @@ fn aiur_fn_461( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = result.output.try_into().unwrap(); __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_6]; record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42376,12 +42236,12 @@ fn aiur_fn_462( 7u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_7, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = result.output.try_into().unwrap(); __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_462] = [__v_11]; record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42437,7 +42297,7 @@ fn aiur_fn_463( 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = result.output.try_into().unwrap(); __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_6]; record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42452,11 +42312,11 @@ fn aiur_fn_463( } }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = result.output.try_into().unwrap(); __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_463] = [__v_8]; record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42497,7 +42357,7 @@ fn aiur_fn_464( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = result.output.try_into().unwrap(); __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_6, __v_10, __v_4]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42522,20 +42382,20 @@ fn aiur_fn_464( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = result.output.try_into().unwrap(); __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = result.output.try_into().unwrap(); __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_16, __v_14, __v_17]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42563,11 +42423,11 @@ fn aiur_fn_464( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = result.output.try_into().unwrap(); __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -42580,14 +42440,14 @@ fn aiur_fn_464( 7u64 => { match __v_18.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; match __v_21.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_23, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = result.output.try_into().unwrap(); __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_23, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_24, __v_22, __v_25]; record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42690,9 +42550,9 @@ fn aiur_fn_465( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = result.output.try_into().unwrap(); __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = result.output.try_into().unwrap(); __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); match __v_7.as_canonical_u64() { @@ -42704,11 +42564,11 @@ fn aiur_fn_465( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = result.output.try_into().unwrap(); __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -42722,7 +42582,7 @@ fn aiur_fn_465( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_10, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = result.output.try_into().unwrap(); __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 0u64 => { @@ -42734,7 +42594,7 @@ fn aiur_fn_465( }, 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_9, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_9, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_465] = [__v_16, __v_17]; record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42769,7 +42629,7 @@ fn aiur_fn_466( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42779,7 +42639,7 @@ fn aiur_fn_466( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -42795,13 +42655,13 @@ fn aiur_fn_466( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_17 + __v_18); let __v_25: G = (__v_23 - __v_24); match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -42819,7 +42679,7 @@ fn aiur_fn_466( 5u64 => { let __v_38: G = G::from_bool((__v_33 == G::ZERO)); let __v_39: G = G::from_bool((__v_31 == G::ZERO)); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = (__v_40 - __v_41); @@ -42835,7 +42695,7 @@ fn aiur_fn_466( }, 1u64 => { let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_46, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = result.output.try_into().unwrap(); __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_46, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_47]; record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42911,9 +42771,9 @@ fn aiur_fn_467( let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_11, __v_13, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_11, __v_13, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -42925,7 +42785,7 @@ fn aiur_fn_467( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_16, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = result.output.try_into().unwrap(); __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_16, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_467] = [__v_17]; record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -42977,14 +42837,14 @@ fn aiur_fn_468( let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_19]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43023,7 +42883,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43048,7 +42908,7 @@ fn aiur_fn_468( let __v_13: G = (__v_6 - __v_10); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_14]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43063,7 +42923,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43085,11 +42945,11 @@ fn aiur_fn_468( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_14]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43107,7 +42967,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43129,13 +42989,13 @@ fn aiur_fn_468( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_16]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43153,7 +43013,7 @@ fn aiur_fn_468( } }, _ => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43169,13 +43029,13 @@ fn aiur_fn_468( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_16]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43193,7 +43053,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43215,17 +43075,17 @@ fn aiur_fn_468( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_16, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_16, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_17]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43254,7 +43114,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43276,14 +43136,14 @@ fn aiur_fn_468( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = result.output.try_into().unwrap(); __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43312,7 +43172,7 @@ fn aiur_fn_468( let __v_17: G = (__v_14 * __v_16); match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_18]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43330,7 +43190,7 @@ fn aiur_fn_468( } }, 4u64 => { - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = result.output.try_into().unwrap(); __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43369,7 +43229,7 @@ fn aiur_fn_469( let __v_5: G = inp[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); @@ -43380,7 +43240,7 @@ fn aiur_fn_469( let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_469] = [__v_18]; record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43446,11 +43306,11 @@ fn aiur_fn_470( let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_470] = [__v_15]; record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43494,10 +43354,10 @@ fn aiur_fn_471( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43517,7 +43377,7 @@ fn aiur_fn_471( let __v_17: G = (__v_10 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_11, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -43527,14 +43387,14 @@ fn aiur_fn_471( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_19 - __v_20); match __v_21.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_471] = [__v_22]; record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43632,7 +43492,7 @@ fn aiur_fn_472( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -43642,7 +43502,7 @@ fn aiur_fn_472( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_472] = [__v_12]; record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43677,7 +43537,7 @@ fn aiur_fn_473( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43726,7 +43586,7 @@ fn aiur_fn_474( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -43768,7 +43628,7 @@ fn aiur_fn_475( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43778,7 +43638,7 @@ fn aiur_fn_475( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -43794,20 +43654,20 @@ fn aiur_fn_475( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_475] = [__v_21, __v_22]; record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_475] = [__v_21, __v_22]; record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43843,7 +43703,7 @@ fn aiur_fn_476( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43853,7 +43713,7 @@ fn aiur_fn_476( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -43861,7 +43721,7 @@ fn aiur_fn_476( let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_5, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_476] = [__v_12, __v_13]; record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -43923,10 +43783,10 @@ fn aiur_fn_477( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43943,7 +43803,7 @@ fn aiur_fn_477( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_12, __v_13, __v_8, __v_16, __v_17, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = result.output.try_into().unwrap(); __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_12, __v_13, __v_8, __v_16, __v_17, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { @@ -43954,7 +43814,7 @@ fn aiur_fn_477( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = result.output.try_into().unwrap(); __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_477] = [__v_20, __v_21]; @@ -43964,7 +43824,7 @@ fn aiur_fn_477( } }, _ => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = result.output.try_into().unwrap(); __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_477] = [__v_19, __v_20]; @@ -43981,7 +43841,7 @@ fn aiur_fn_477( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = result.output.try_into().unwrap(); __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_477] = [__v_19, __v_20]; @@ -44027,7 +43887,7 @@ fn aiur_fn_478( let __v_9: G = (__v_0 - __v_3); match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = result.output.try_into().unwrap(); __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { @@ -44037,14 +43897,14 @@ fn aiur_fn_478( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = result.output.try_into().unwrap(); __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_478] = [__v_14]; record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -44091,9 +43951,9 @@ fn aiur_fn_479( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { @@ -44106,7 +43966,7 @@ fn aiur_fn_479( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_479] = [__v_10, __v_11]; @@ -44125,7 +43985,7 @@ fn aiur_fn_479( 1u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_479] = [__v_10, __v_11]; @@ -44133,14 +43993,14 @@ fn aiur_fn_479( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = result.output.try_into().unwrap(); __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_1, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = result.output.try_into().unwrap(); __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_479] = [__v_13, __v_14]; @@ -44151,7 +44011,7 @@ fn aiur_fn_479( let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_479] = [__v_14, __v_15]; @@ -44159,7 +44019,7 @@ fn aiur_fn_479( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = result.output.try_into().unwrap(); __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_479] = [__v_14, __v_15]; @@ -44213,7 +44073,7 @@ fn aiur_fn_480( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -44224,16 +44084,16 @@ fn aiur_fn_480( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = result.output.try_into().unwrap(); __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_480] = [__v_13, __v_14]; @@ -44241,7 +44101,7 @@ fn aiur_fn_480( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = result.output.try_into().unwrap(); __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_480] = [__v_10, __v_11]; @@ -44281,7 +44141,7 @@ fn aiur_fn_481( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = result.output.try_into().unwrap(); __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -44292,16 +44152,16 @@ fn aiur_fn_481( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = result.output.try_into().unwrap(); __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_481] = [__v_13, __v_14]; @@ -44309,7 +44169,7 @@ fn aiur_fn_481( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = result.output.try_into().unwrap(); __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_481] = [__v_10, __v_11]; @@ -44348,16 +44208,16 @@ fn aiur_fn_482( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_482] = [__v_11, __v_12]; @@ -44394,16 +44254,16 @@ fn aiur_fn_483( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 - __v_9); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_483] = [__v_11, __v_12]; @@ -44440,23 +44300,23 @@ fn aiur_fn_484( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = result.output.try_into().unwrap(); __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = result.output.try_into().unwrap(); __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_484] = [__v_14, __v_15]; @@ -44506,9 +44366,9 @@ fn aiur_fn_485( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -44522,15 +44382,15 @@ fn aiur_fn_485( return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); } let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = result.output.try_into().unwrap(); __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_1 + __v_2); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9, __v_1, __v_3, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = result.output.try_into().unwrap(); __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9, __v_1, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_485] = []; record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44570,7 +44430,7 @@ fn aiur_fn_486( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_8]; record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -44600,7 +44460,7 @@ fn aiur_fn_487( let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { @@ -44630,7 +44490,7 @@ fn aiur_fn_487( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_5, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = result.output.try_into().unwrap(); __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_487] = []; record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44693,7 +44553,7 @@ fn aiur_fn_488( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_3 + __v_16); - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = result.output.try_into().unwrap(); __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_488] = []; record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44756,7 +44616,7 @@ fn aiur_fn_489( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -44798,7 +44658,7 @@ fn aiur_fn_490( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = result.output.try_into().unwrap(); __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_490] = []; record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44827,7 +44687,7 @@ fn aiur_fn_491( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = result.output.try_into().unwrap(); __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_491] = []; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44844,7 +44704,7 @@ fn aiur_fn_491( let __v_13: G = { let __values: [G; 3] = [__v_12, __v_9, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_10, __v_15, __v_2, __v_3, __v_4, __v_13, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = result.output.try_into().unwrap(); __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_10, __v_15, __v_2, __v_3, __v_4, __v_13, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_491] = []; record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44882,13 +44742,13 @@ fn aiur_fn_492( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12, __v_13, __v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12, __v_13, __v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -44896,7 +44756,7 @@ fn aiur_fn_492( } let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 3] = [__v_17, __v_8, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_9, __v_1, __v_2, __v_3, __v_18, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = result.output.try_into().unwrap(); __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_9, __v_1, __v_2, __v_3, __v_18, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_492] = []; record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44926,12 +44786,12 @@ fn aiur_fn_493( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_8, __v_7, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_8, __v_7, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_493] = []; record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -44966,7 +44826,7 @@ fn aiur_fn_494( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_8]; record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45014,7 +44874,7 @@ fn aiur_fn_495( let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_10, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_495] = [__v_11, __v_12]; @@ -45054,10 +44914,10 @@ fn aiur_fn_496( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = result.output.try_into().unwrap(); __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_1, __v_10, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_1, __v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_496] = []; record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -45086,7 +44946,7 @@ fn aiur_fn_497( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -45095,7 +44955,7 @@ fn aiur_fn_497( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -45104,7 +44964,7 @@ fn aiur_fn_497( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_8, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { @@ -45112,13 +44972,13 @@ fn aiur_fn_497( } let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_9, __v_1, __v_14, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = result.output.try_into().unwrap(); __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_9, __v_1, __v_14, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_497] = []; record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -45128,7 +44988,7 @@ fn aiur_fn_497( let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -45137,7 +44997,7 @@ fn aiur_fn_497( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; @@ -45153,17 +45013,17 @@ fn aiur_fn_497( let __v_29: G = __loaded[10]; match __v_19.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_30, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); if (__v_31 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); } - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = result.output.try_into().unwrap(); __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_24, __v_12, __v_33, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_24, __v_12, __v_33, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_497] = []; record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -45236,7 +45096,7 @@ fn aiur_fn_498( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_498] = [__v_6]; record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45277,7 +45137,7 @@ fn aiur_fn_499( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -45293,9 +45153,9 @@ fn aiur_fn_499( let __v_18: G = __loaded[10]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_19, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = result.output.try_into().unwrap(); __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { @@ -45305,7 +45165,7 @@ fn aiur_fn_499( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_499] = [__v_21]; record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45317,7 +45177,7 @@ fn aiur_fn_499( } }, _ => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_499] = [__v_19]; record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45351,7 +45211,7 @@ fn aiur_fn_500( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45361,7 +45221,7 @@ fn aiur_fn_500( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = result.output.try_into().unwrap(); __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_500] = [__v_7]; record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45413,14 +45273,14 @@ fn aiur_fn_501( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_6]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45430,7 +45290,7 @@ fn aiur_fn_501( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_7]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45442,7 +45302,7 @@ fn aiur_fn_501( } }, 4u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45452,7 +45312,7 @@ fn aiur_fn_501( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_7]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45464,7 +45324,7 @@ fn aiur_fn_501( } }, 5u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45474,7 +45334,7 @@ fn aiur_fn_501( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_7]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45486,7 +45346,7 @@ fn aiur_fn_501( } }, 6u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45496,7 +45356,7 @@ fn aiur_fn_501( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -45506,7 +45366,7 @@ fn aiur_fn_501( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_8]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45529,7 +45389,7 @@ fn aiur_fn_501( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_501] = [__v_6]; record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45566,7 +45426,7 @@ fn aiur_fn_502( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = result.output.try_into().unwrap(); __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -45576,7 +45436,7 @@ fn aiur_fn_502( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_502] = [__v_6]; record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45608,7 +45468,7 @@ fn aiur_fn_503( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_503] = [__v_4]; record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45655,7 +45515,7 @@ fn aiur_fn_504( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -45691,10 +45551,10 @@ fn aiur_fn_504( let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 32] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = (__v_19 - __v_53); - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = (__v_56 - __v_55); @@ -45706,7 +45566,7 @@ fn aiur_fn_504( let __v_61: G = { let __values: [G; 3] = [__v_60, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_62: G = G::from_u64(1); let __v_63: G = (__v_3 + __v_62); - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_61, __v_1, __v_6, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_61, __v_1, __v_6, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_64]; record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45715,7 +45575,7 @@ fn aiur_fn_504( 0u64 => { let __v_60: G = G::from_u64(1); let __v_61: G = (__v_3 + __v_60); - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_62]; record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45729,7 +45589,7 @@ fn aiur_fn_504( _ => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = result.output.try_into().unwrap(); __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_504] = [__v_20]; record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45770,7 +45630,7 @@ fn aiur_fn_505( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -45789,17 +45649,17 @@ fn aiur_fn_505( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_11, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = result.output.try_into().unwrap(); __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_11, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_23, __v_2, __v_24, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = result.output.try_into().unwrap(); __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_23, __v_2, __v_24, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_505] = []; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = result.output.try_into().unwrap(); __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_505] = []; record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -45861,48 +45721,48 @@ fn aiur_fn_506( } }, 3u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_8]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_8]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_8]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = result.output.try_into().unwrap(); __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_10]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45915,7 +45775,7 @@ fn aiur_fn_506( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = result.output.try_into().unwrap(); __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_506] = [__v_6]; record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -45944,7 +45804,7 @@ fn aiur_fn_507( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = result.output.try_into().unwrap(); __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -45954,7 +45814,7 @@ fn aiur_fn_507( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -45965,9 +45825,9 @@ fn aiur_fn_507( }, 1u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -45994,7 +45854,7 @@ fn aiur_fn_507( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_13, __v_16, __v_17, __v_24, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = result.output.try_into().unwrap(); __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_13, __v_16, __v_17, __v_24, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_507] = [__v_25]; record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46044,7 +45904,7 @@ fn aiur_fn_508( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = result.output.try_into().unwrap(); __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_10]; record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46062,7 +45922,7 @@ fn aiur_fn_508( let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = result.output.try_into().unwrap(); __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_508] = [__v_14]; record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46100,10 +45960,10 @@ fn aiur_fn_509( let __v_7: G = (__v_1 - __v_2); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = result.output.try_into().unwrap(); __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_509] = [__v_10]; record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46117,7 +45977,7 @@ fn aiur_fn_509( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -46126,7 +45986,7 @@ fn aiur_fn_509( let __v_16: G = __loaded[2]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_13 - __v_19); let __v_21: G = G::from_u64(1); @@ -46148,7 +46008,7 @@ fn aiur_fn_509( let __v_26: G = { let __values: [G; 3] = [__v_25, __v_9, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = (__v_2 + __v_27); - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1, __v_28, __v_26, __v_4, __v_5, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = result.output.try_into().unwrap(); __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1, __v_28, __v_26, __v_4, __v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_509] = [__v_29]; record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46190,7 +46050,7 @@ fn aiur_fn_510( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -46200,7 +46060,7 @@ fn aiur_fn_510( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = result.output.try_into().unwrap(); __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_510] = [__v_6]; record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46258,7 +46118,7 @@ fn aiur_fn_511( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_10]; record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46267,7 +46127,7 @@ fn aiur_fn_511( } }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = result.output.try_into().unwrap(); __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_511] = [__v_9]; record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46303,20 +46163,20 @@ fn aiur_fn_512( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_11, __v_2, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = result.output.try_into().unwrap(); __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_11, __v_2, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_13, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = result.output.try_into().unwrap(); __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(2); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_15, __v_0, __v_4, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_17, __v_8, __v_3, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = result.output.try_into().unwrap(); __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_17, __v_8, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_18, __v_3, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_18, __v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -46325,7 +46185,7 @@ fn aiur_fn_512( let __v_25: G = G::from_u64(5); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_20, __v_24, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_27, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_27, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_512] = [__v_28]; record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46351,14 +46211,14 @@ fn aiur_fn_513( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = result.output.try_into().unwrap(); __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_513] = [__v_6]; record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_4, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_513] = [__v_5]; record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46393,12 +46253,12 @@ fn aiur_fn_514( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_10, __v_5, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_514] = [__v_11]; record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46441,16 +46301,16 @@ fn aiur_fn_515( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = result.output.try_into().unwrap(); __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = result.output.try_into().unwrap(); __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_515] = [__v_17]; record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46492,12 +46352,12 @@ fn aiur_fn_516( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_516] = [__v_6]; record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46536,7 +46396,7 @@ fn aiur_fn_517( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_517] = [__v_4]; record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46546,7 +46406,7 @@ fn aiur_fn_517( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_4, __v_5, __v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_4, __v_5, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_517] = [__v_7]; record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46568,7 +46428,7 @@ fn aiur_fn_518( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -46628,16 +46488,16 @@ fn aiur_fn_519( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = result.output.try_into().unwrap(); __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_519] = [__v_17]; record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46679,15 +46539,15 @@ fn aiur_fn_520( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_520] = [__v_8]; record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46742,7 +46602,7 @@ fn aiur_fn_521( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = result.output.try_into().unwrap(); __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_521] = [__v_10]; @@ -46789,7 +46649,7 @@ fn aiur_fn_522( let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_522] = [__v_12]; @@ -46834,7 +46694,7 @@ fn aiur_fn_523( let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = result.output.try_into().unwrap(); __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_523] = [__v_17]; record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46876,7 +46736,7 @@ fn aiur_fn_524( let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_12, __v_1, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_524] = [__v_15]; record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -46910,7 +46770,7 @@ fn aiur_fn_525( }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -46949,17 +46809,17 @@ fn aiur_fn_526( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_9 + __v_10); let __v_16: G = (__v_8 + __v_15); - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = result.output.try_into().unwrap(); __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_14, __v_17, __v_16, __v_3, __v_4, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = result.output.try_into().unwrap(); __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_14, __v_17, __v_16, __v_3, __v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_0, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = G::from_u64(1); @@ -46975,24 +46835,24 @@ fn aiur_fn_526( let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_6, __v_25, __v_28, __v_31, __v_34, __v_12, __v_13, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_6, __v_25, __v_28, __v_31, __v_34, __v_12, __v_13, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; let __v_39: G = __r_arr[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_40 + __v_41); let __v_43: G = (__v_16 + __v_42); - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_45, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_45, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_46, __v_41, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = result.output.try_into().unwrap(); __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_46, __v_41, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = (__v_43 - __v_49); @@ -47001,15 +46861,15 @@ fn aiur_fn_526( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = { let __values: [G; 4] = [__v_53, __v_52, __v_54, __v_54]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(2); let __v_58: G = G::from_u64(0); let __v_59: G = { let __values: [G; 4] = [__v_57, __v_1, __v_5, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_59, __v_17, __v_8, __v_43, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = result.output.try_into().unwrap(); __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_59, __v_17, __v_8, __v_43, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_60, __v_40, __v_42, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_60, __v_40, __v_42, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = G::from_u64(3); let __v_64: G = G::from_u64(0); @@ -47018,11 +46878,11 @@ fn aiur_fn_526( let __v_67: G = G::from_u64(1); let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_69: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_37, __v_38, __v_36, __v_7, __v_11, __v_40, __v_16, __v_68, __v_12, __v_13, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = result.output.try_into().unwrap(); __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_37, __v_38, __v_36, __v_7, __v_11, __v_40, __v_16, __v_68, __v_12, __v_13, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_65, __v_70]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_65, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __ret: [G; OUT_526] = [__v_72]; record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47051,14 +46911,14 @@ fn aiur_fn_527( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_527] = [__v_9]; record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_527] = [__v_6]; record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47103,13 +46963,13 @@ fn aiur_fn_528( let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_8, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_1 - __v_16); let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_15, __v_17, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = result.output.try_into().unwrap(); __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_15, __v_17, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_528] = [__v_20]; record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47150,7 +47010,7 @@ fn aiur_fn_529( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_1, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = result.output.try_into().unwrap(); __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_1, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); @@ -47165,7 +47025,7 @@ fn aiur_fn_529( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_14, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_8 + __v_23); - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; @@ -47177,7 +47037,7 @@ fn aiur_fn_529( _ => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_8 + __v_19); - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -47189,11 +47049,11 @@ fn aiur_fn_529( } }, _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_529] = [__v_13, __v_14, __v_15, __v_0]; record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47215,7 +47075,7 @@ fn aiur_fn_530( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -47264,7 +47124,7 @@ fn aiur_fn_530( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 1u64 => { @@ -47279,7 +47139,7 @@ fn aiur_fn_530( }, 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_1, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_1, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_530] = [__v_49]; record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47345,14 +47205,14 @@ fn aiur_fn_531( let __v_16: G = __loaded[10]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = (__v_2 + __v_19); - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_531] = [__v_22]; @@ -47362,7 +47222,7 @@ fn aiur_fn_531( 0u64 => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_2 + __v_18); - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_531] = [__v_20]; record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47376,7 +47236,7 @@ fn aiur_fn_531( _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_2 + __v_17); - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = result.output.try_into().unwrap(); __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_531] = [__v_19]; record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47404,7 +47264,7 @@ fn aiur_fn_532( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -47453,7 +47313,7 @@ fn aiur_fn_532( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 32] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_48.as_canonical_u64() { 1u64 => { @@ -47463,7 +47323,7 @@ fn aiur_fn_532( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -47479,7 +47339,7 @@ fn aiur_fn_532( let __v_60: G = __loaded[10]; match __v_50.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __ret: [G; OUT_532] = [__v_61]; record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47523,16 +47383,16 @@ fn aiur_fn_533( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_6, __v_8, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_6, __v_8, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -47543,7 +47403,7 @@ fn aiur_fn_533( match __v_12.as_canonical_u64() { 2u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_13, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_533] = [__v_17, __v_18]; @@ -47598,7 +47458,7 @@ fn aiur_fn_534( _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_534] = [__v_9, __v_10]; @@ -47628,10 +47488,10 @@ fn aiur_fn_535( let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = result.output.try_into().unwrap(); __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_535] = [__v_6, __v_5]; record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47660,7 +47520,7 @@ fn aiur_fn_536( 5u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = result.output.try_into().unwrap(); __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_536] = [__v_8, __v_9]; @@ -47704,9 +47564,9 @@ fn aiur_fn_537( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = result.output.try_into().unwrap(); __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_537] = [__v_9]; @@ -47751,7 +47611,7 @@ fn aiur_fn_538( let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_538] = [__v_14]; record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47794,7 +47654,7 @@ fn aiur_fn_539( let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_539] = [__v_16]; record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47819,10 +47679,10 @@ fn aiur_fn_540( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = result.output.try_into().unwrap(); __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_540] = [__v_7, __v_6]; record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47861,7 +47721,7 @@ fn aiur_fn_541( let __v_8: G = (__v_1 - __v_7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_8, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = result.output.try_into().unwrap(); __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_541] = [__v_11, __v_12]; @@ -47907,7 +47767,7 @@ fn aiur_fn_542( let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = result.output.try_into().unwrap(); __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_542] = [__v_13]; record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -47954,7 +47814,7 @@ fn aiur_fn_543( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -47970,11 +47830,11 @@ fn aiur_fn_543( let __v_27: G = __loaded[10]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_1, __v_14, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = result.output.try_into().unwrap(); __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_1, __v_14, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = (__v_12 + __v_29); - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = result.output.try_into().unwrap(); __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 3] = [__v_32, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -48014,7 +47874,7 @@ fn aiur_fn_544( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_544] = [__v_10]; record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48059,7 +47919,7 @@ fn aiur_fn_545( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -48075,15 +47935,15 @@ fn aiur_fn_545( let __v_27: G = __loaded[10]; match __v_17.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_11, __v_19, __v_20, __v_21, __v_14, __v_3, __v_4, __v_5, __v_7, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = result.output.try_into().unwrap(); __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_11, __v_19, __v_20, __v_21, __v_14, __v_3, __v_4, __v_5, __v_7, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_28, __v_9, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_28, __v_9, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_9 + __v_32); - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_545] = [__v_35]; @@ -48091,7 +47951,7 @@ fn aiur_fn_545( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = result.output.try_into().unwrap(); __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_545] = [__v_28]; record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48144,7 +48004,7 @@ fn aiur_fn_546( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -48160,21 +48020,21 @@ fn aiur_fn_546( let __v_28: G = __loaded[10]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_23, __v_12, __v_13, __v_14, __v_15, __v_1, __v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = result.output.try_into().unwrap(); __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_23, __v_12, __v_13, __v_14, __v_15, __v_1, __v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_10 + __v_30); - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_29, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_546] = [__v_33]; record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_546] = [__v_29]; record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48210,11 +48070,11 @@ fn aiur_fn_547( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = (__v_6 + __v_4); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_11, __v_12, __v_13, __v_2, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = result.output.try_into().unwrap(); __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_11, __v_12, __v_13, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_14.as_canonical_u64() { 1u64 => { @@ -48236,49 +48096,49 @@ fn aiur_fn_547( let __v_15: G = __mc_out___mc_0[0]; let __v_16: G = __mc_out___mc_0[1]; let __v_17: G = __mc_out___mc_0[2]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_18, __v_14, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = result.output.try_into().unwrap(); __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_18, __v_14, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __v_28: G = __r_arr[3]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_29, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_19, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_19, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_19, __v_3, __v_5, __v_15, __v_16, __v_17, __v_14, __v_3, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = result.output.try_into().unwrap(); __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_19, __v_3, __v_5, __v_15, __v_16, __v_17, __v_14, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_19, __v_20, __v_32, __v_3, __v_21, __v_5, __v_14, __v_3, __v_8, __v_9, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_19, __v_20, __v_32, __v_3, __v_21, __v_5, __v_14, __v_3, __v_8, __v_9, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_31, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_31, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = (__v_21 + __v_36); let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_37, __v_39, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_37, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -48291,10 +48151,10 @@ fn aiur_fn_547( let __v_54: G = (__v_3 + __v_53); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_54 - __v_55); - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_51, __v_3, __v_56, __v_4, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = result.output.try_into().unwrap(); __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_51, __v_3, __v_56, __v_4, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_57, __v_4, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_57, __v_4, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(1); let __v_61: G = (__v_54 + __v_60); @@ -48306,7 +48166,7 @@ fn aiur_fn_547( let __v_67: G = G::from_u64(0); let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_69: G = G::from_u64(0); - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_68, __v_4, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = result.output.try_into().unwrap(); __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_68, __v_4, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(3); let __v_72: G = G::from_u64(0); @@ -48318,13 +48178,13 @@ fn aiur_fn_547( let __v_78: G = G::from_u64(5); let __v_79: G = G::from_u64(0); let __v_80: G = { let __values: [G; 4] = [__v_78, __v_59, __v_77, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_80, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_80, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_81, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_81, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_82, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_82, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_83, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_83, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __ret: [G; OUT_547] = [__v_84]; record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48365,13 +48225,13 @@ fn aiur_fn_548( let __v_20: G = inp[20]; let __v_21: G = (__v_8 + __v_9); let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = result.output.try_into().unwrap(); __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = result.output.try_into().unwrap(); __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_24, __v_25, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = result.output.try_into().unwrap(); __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_24, __v_25, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); @@ -48386,14 +48246,14 @@ fn aiur_fn_548( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = G::from_u64(0); - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_14, __v_29, __v_32, __v_35, __v_38, __v_19, __v_20, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = result.output.try_into().unwrap(); __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_14, __v_29, __v_32, __v_35, __v_38, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __v_43: G = __r_arr[3]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = (__v_7 + __v_44); let __v_47: G = (__v_6 + __v_46); @@ -48407,25 +48267,25 @@ fn aiur_fn_548( let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_57: G = G::from_u64(0); - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_56, __v_44, __v_44, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = result.output.try_into().unwrap(); __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_56, __v_44, __v_44, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = G::from_u64(1); let __v_60: G = G::from_u64(1); let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_58, __v_41, __v_42, __v_40, __v_13, __v_15, __v_5, __v_6, __v_7, __v_44, __v_23, __v_61, __v_19, __v_20, __v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = result.output.try_into().unwrap(); __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_58, __v_41, __v_42, __v_40, __v_13, __v_15, __v_5, __v_6, __v_7, __v_44, __v_23, __v_61, __v_19, __v_20, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_6 + __v_7); let __v_65: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_40, __v_64, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_40, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_63, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_63, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_67, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_67, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_68, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_68, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_69, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_69, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_548] = [__v_70]; record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48462,7 +48322,7 @@ fn aiur_fn_549( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = result.output.try_into().unwrap(); __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_549] = [__v_10]; @@ -48497,7 +48357,7 @@ fn aiur_fn_550( }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -48548,36 +48408,36 @@ fn aiur_fn_551( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_8 + __v_9); let __v_22: G = (__v_7 + __v_21); let __v_23: G = (__v_6 + __v_22); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_9 - __v_16); let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_24, __v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_27, __v_28, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_27, __v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_29, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_29, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_33, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_32, __v_34, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_32, __v_34, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = (__v_23 + __v_36); let __v_38: G = G::from_u64(2); @@ -48586,27 +48446,27 @@ fn aiur_fn_551( let __v_41: G = G::from_u64(1); let __v_42: G = (__v_37 - __v_41); let __v_43: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_40, __v_6, __v_42, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_40, __v_6, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(1); let __v_46: G = (__v_37 - __v_45); let __v_47: G = (__v_46 - __v_6); let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_44, __v_7, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_44, __v_7, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = (__v_37 - __v_50); let __v_52: G = (__v_51 - __v_6); let __v_53: G = (__v_52 - __v_7); let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_49, __v_8, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_49, __v_8, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_57, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(1); let __v_61: G = (__v_9 - __v_60); @@ -48616,19 +48476,19 @@ fn aiur_fn_551( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_66, __v_36, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_66, __v_36, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(3); let __v_70: G = G::from_u64(0); let __v_71: G = { let __values: [G; 4] = [__v_69, __v_59, __v_68, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_71, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = result.output.try_into().unwrap(); __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_71, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(3); let __v_74: G = G::from_u64(0); let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_76: G = G::from_u64(1); let __v_77: G = (__v_14 + __v_76); - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = result.output.try_into().unwrap(); __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; let __ret: [G; OUT_551] = [__v_78]; record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48661,7 +48521,7 @@ fn aiur_fn_552( let __v_7: G = (__v_4 + __v_5); let __v_8: G = (__v_3 + __v_7); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = result.output.try_into().unwrap(); __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -48670,7 +48530,7 @@ fn aiur_fn_552( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -48711,13 +48571,13 @@ fn aiur_fn_553( let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_553] = [__v_8]; record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48774,7 +48634,7 @@ fn aiur_fn_554( let __v_19: G = __loaded[10]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_20 - __v_0); let __v_22: G = G::from_bool((__v_21 == G::ZERO)); @@ -48784,7 +48644,7 @@ fn aiur_fn_554( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -48801,7 +48661,7 @@ fn aiur_fn_554( 0u64 => { let __v_25: G = G::from_u64(1); let __v_26: G = (__v_5 + __v_25); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_554] = [__v_27]; record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48815,7 +48675,7 @@ fn aiur_fn_554( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = result.output.try_into().unwrap(); __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_554] = [__v_22]; record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -48858,9 +48718,9 @@ fn aiur_fn_555( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = result.output.try_into().unwrap(); __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = result.output.try_into().unwrap(); __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_555] = [__v_9]; @@ -48896,7 +48756,7 @@ fn aiur_fn_556( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -48957,12 +48817,12 @@ fn aiur_fn_557( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = result.output.try_into().unwrap(); __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_557] = [__v_11]; @@ -49037,13 +48897,13 @@ fn aiur_fn_558( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = result.output.try_into().unwrap(); __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_558] = []; record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -49089,7 +48949,7 @@ fn aiur_fn_559( let __v_12: G = inp[12]; match __v_1.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -49105,7 +48965,7 @@ fn aiur_fn_559( let __v_24: G = __loaded[10]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; if (__v_25 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() }); @@ -49138,7 +48998,7 @@ fn aiur_fn_560( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -49154,22 +49014,22 @@ fn aiur_fn_560( let __v_13: G = __loaded[10]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_15 - __v_16); match __v_17.as_canonical_u64() { 0u64 => { let __v_18: G = (__v_6 + __v_7); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 0u64 => { @@ -49179,16 +49039,16 @@ fn aiur_fn_560( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = (__v_25 - __v_26); match __v_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -49274,16 +49134,16 @@ fn aiur_fn_561( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = result.output.try_into().unwrap(); __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_14, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = result.output.try_into().unwrap(); __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_9 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -49297,7 +49157,7 @@ fn aiur_fn_561( let __v_26: G = __loaded[8]; let __v_27: G = __loaded[9]; let __v_28: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_30: G = __loaded[0]; @@ -49315,23 +49175,23 @@ fn aiur_fn_561( 5u64 => { match __v_30.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = result.output.try_into().unwrap(); __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3, __v_41, __v_44, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3, __v_41, __v_44, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); } let __v_47: G = (__v_33 + __v_34); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_32, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_32, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_48, __v_49, __v_50, __v_35, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = result.output.try_into().unwrap(); __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_48, __v_49, __v_50, __v_35, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_51.as_canonical_u64() { 1u64 => { @@ -49353,48 +49213,48 @@ fn aiur_fn_561( let __v_52: G = __mc_out___mc_0[0]; let __v_53: G = __mc_out___mc_0[1]; let __v_54: G = __mc_out___mc_0[2]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_15, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_15, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_55, __v_51, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = result.output.try_into().unwrap(); __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_55, __v_51, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_56, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_56, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_56, __v_21, __v_19, __v_52, __v_53, __v_54, __v_51, __v_21, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = result.output.try_into().unwrap(); __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_56, __v_21, __v_19, __v_52, __v_53, __v_54, __v_51, __v_21, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_56, __v_57, __v_59, __v_21, __v_58, __v_19, __v_51, __v_21, __v_12, __v_13, __v_61]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = result.output.try_into().unwrap(); __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_56, __v_57, __v_59, __v_21, __v_58, __v_19, __v_51, __v_21, __v_12, __v_13, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_57, __v_14, __v_12, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_57, __v_14, __v_12, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_51, __v_19, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_51, __v_19, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = result.output.try_into().unwrap(); __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_68, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_68, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_57, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = result.output.try_into().unwrap(); __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_57, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = G::from_u64(0); - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_57, __v_14, __v_72]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = result.output.try_into().unwrap(); __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_57, __v_14, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_56, __v_74]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_56, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = __r_arr[1]; let __v_77: G = __r_arr[2]; let __v_78: G = __r_arr[3]; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_51, __v_60, __v_62, __v_69, __v_71, __v_57, __v_59, __v_76, __v_77, __v_78, __v_12, __v_13, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = result.output.try_into().unwrap(); __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_51, __v_60, __v_62, __v_69, __v_71, __v_57, __v_59, __v_76, __v_77, __v_78, __v_12, __v_13, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_79, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = result.output.try_into().unwrap(); __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_79, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_561] = []; record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -49429,13 +49289,13 @@ fn aiur_fn_562( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = result.output.try_into().unwrap(); __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = result.output.try_into().unwrap(); __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_562] = [__v_6]; record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -49470,7 +49330,7 @@ fn aiur_fn_563( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -49487,14 +49347,14 @@ fn aiur_fn_563( match __v_7.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_8, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = result.output.try_into().unwrap(); __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_563] = [__v_26]; @@ -49510,7 +49370,7 @@ fn aiur_fn_563( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = result.output.try_into().unwrap(); __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_563] = [__v_27]; @@ -49555,7 +49415,7 @@ fn aiur_fn_564( 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = result.output.try_into().unwrap(); __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 6] = [__v_6, __v_2, __v_7, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_564] = [__v_9]; @@ -49598,7 +49458,7 @@ fn aiur_fn_565( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = result.output.try_into().unwrap(); __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_7, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_565] = [__v_9]; @@ -49655,7 +49515,7 @@ fn aiur_fn_566( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_7, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = result.output.try_into().unwrap(); __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -49692,14 +49552,14 @@ fn aiur_fn_567( match __v_4.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = result.output.try_into().unwrap(); __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_567] = [__v_7]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = result.output.try_into().unwrap(); __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_567] = [__v_6]; record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -49738,7 +49598,7 @@ fn aiur_fn_568( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -49755,7 +49615,7 @@ fn aiur_fn_568( match __v_9.as_canonical_u64() { 5u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_568] = [__v_22]; @@ -49765,7 +49625,7 @@ fn aiur_fn_568( _ => { let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = result.output.try_into().unwrap(); __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_568] = [__v_23]; @@ -49827,7 +49687,7 @@ fn aiur_fn_569( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { @@ -49837,7 +49697,7 @@ fn aiur_fn_569( }, 0u64 => { let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_1, __v_2, __v_2, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_1, __v_2, __v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; match __v_38.as_canonical_u64() { @@ -49901,13 +49761,13 @@ fn aiur_fn_570( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_21, __v_22]; @@ -49915,9 +49775,9 @@ fn aiur_fn_570( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = result.output.try_into().unwrap(); __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -49937,7 +49797,7 @@ fn aiur_fn_570( 0u64 => { let __v_32: G = G::from_u64(1); let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_34, __v_35]; @@ -49955,7 +49815,7 @@ fn aiur_fn_570( _ => { let __v_32: G = G::from_u64(1); let __v_33: G = (__v_3 + __v_32); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_34, __v_35]; @@ -49972,7 +49832,7 @@ fn aiur_fn_570( _ => { let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = result.output.try_into().unwrap(); __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_570] = [__v_20, __v_21]; @@ -50022,7 +49882,7 @@ fn aiur_fn_571( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -50038,17 +49898,17 @@ fn aiur_fn_571( let __v_20: G = __loaded[10]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_21); - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_571] = [__v_23]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = result.output.try_into().unwrap(); __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_571] = [__v_21]; record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50080,7 +49940,7 @@ fn aiur_fn_572( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -50129,7 +49989,7 @@ fn aiur_fn_572( let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 1u64 => { @@ -50142,7 +50002,7 @@ fn aiur_fn_572( match __v_12.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_13, __v_1, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_13, __v_1, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_572] = [__v_49]; record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50210,14 +50070,14 @@ fn aiur_fn_573( let __v_16: G = __loaded[10]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_15); match __v_18.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); let __v_20: G = (__v_2 + __v_19); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_573] = [__v_21]; record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50234,7 +50094,7 @@ fn aiur_fn_573( _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_2 + __v_17); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = result.output.try_into().unwrap(); __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_573] = [__v_19]; record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50262,7 +50122,7 @@ fn aiur_fn_574( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50278,7 +50138,7 @@ fn aiur_fn_574( let __v_14: G = __loaded[10]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_9, __v_7, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_9, __v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_574] = [__v_15]; record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50324,7 +50184,7 @@ fn aiur_fn_575( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -50340,20 +50200,20 @@ fn aiur_fn_575( let __v_18: G = __loaded[10]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = result.output.try_into().unwrap(); __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_19, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = result.output.try_into().unwrap(); __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_19, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_575] = [__v_22]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = result.output.try_into().unwrap(); __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_575] = [__v_19]; record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50388,11 +50248,11 @@ fn aiur_fn_576( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = result.output.try_into().unwrap(); __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = result.output.try_into().unwrap(); __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_576] = [__v_9]; record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50423,10 +50283,10 @@ fn aiur_fn_577( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -50436,7 +50296,7 @@ fn aiur_fn_577( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = result.output.try_into().unwrap(); __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -50448,7 +50308,7 @@ fn aiur_fn_577( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -50464,7 +50324,7 @@ fn aiur_fn_577( let __v_23: G = __loaded[10]; match __v_13.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = { let __a_val = __v_24.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_25.as_canonical_u64() { @@ -50477,9 +50337,9 @@ fn aiur_fn_577( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_26, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = result.output.try_into().unwrap(); __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_26, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 0u64 => { @@ -50551,7 +50411,7 @@ fn aiur_fn_578( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = result.output.try_into().unwrap(); __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_578] = [__v_4]; record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50587,16 +50447,16 @@ fn aiur_fn_579( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = result.output.try_into().unwrap(); __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_3 + __v_13); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_12, __v_2, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = result.output.try_into().unwrap(); __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_12, __v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_579] = [__v_15]; record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50623,12 +50483,12 @@ fn aiur_fn_580( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_2, __v_3, __v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_2, __v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_580] = []; record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -50662,11 +50522,11 @@ fn aiur_fn_581( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_581] = [__v_6, __v_7]; @@ -50674,7 +50534,7 @@ fn aiur_fn_581( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -50690,7 +50550,7 @@ fn aiur_fn_581( let __v_17: G = __loaded[10]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = result.output.try_into().unwrap(); __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_581] = [__v_10, __v_18]; @@ -50698,7 +50558,7 @@ fn aiur_fn_581( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = result.output.try_into().unwrap(); __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_581] = [__v_18, __v_19]; @@ -50746,22 +50606,22 @@ fn aiur_fn_582( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_582] = [__v_7]; record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = result.output.try_into().unwrap(); __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = result.output.try_into().unwrap(); __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_582] = [__v_9]; record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50805,17 +50665,17 @@ fn aiur_fn_583( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = result.output.try_into().unwrap(); __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_583] = []; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -50831,19 +50691,19 @@ fn aiur_fn_583( let __v_20: G = __loaded[10]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); } - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_583] = []; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = result.output.try_into().unwrap(); __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_583] = []; record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -50892,7 +50752,7 @@ fn aiur_fn_584( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -50908,22 +50768,22 @@ fn aiur_fn_584( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_15, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = result.output.try_into().unwrap(); __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_15, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = (__v_26 - __v_27); match __v_28.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = result.output.try_into().unwrap(); __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { 1u64 => { @@ -50933,7 +50793,7 @@ fn aiur_fn_584( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_30]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50942,7 +50802,7 @@ fn aiur_fn_584( } }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_29]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50951,7 +50811,7 @@ fn aiur_fn_584( } }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_26]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -50960,7 +50820,7 @@ fn aiur_fn_584( } }, _ => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = result.output.try_into().unwrap(); __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_584] = [__v_23]; record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -51029,7 +50889,7 @@ fn aiur_fn_585( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -51043,7 +50903,7 @@ fn aiur_fn_585( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -51061,15 +50921,15 @@ fn aiur_fn_585( 6u64 => { match __v_25.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_27, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = result.output.try_into().unwrap(); __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_27, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_36, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_36, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_37, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_37, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; match __v_38.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = result.output.try_into().unwrap(); __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_585] = [__v_39]; record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -51155,7 +51015,7 @@ fn aiur_fn_586( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_17, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -51171,12 +51031,12 @@ fn aiur_fn_586( let __v_34: G = __loaded[10]; match __v_24.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_27, __v_21, __v_26, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = result.output.try_into().unwrap(); __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_27, __v_21, __v_26, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_19 + __v_37); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_22, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = result.output.try_into().unwrap(); __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_22, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = { let __values: [G; 5] = [__v_36, __v_21, __v_30, __v_35, __v_39]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_586] = [__v_40]; @@ -51230,31 +51090,31 @@ fn aiur_fn_587( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_5 + __v_10); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_5 - __v_12); let __v_20: G = (__v_19 + __v_10); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_18, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = result.output.try_into().unwrap(); __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_18, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = result.output.try_into().unwrap(); __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = result.output.try_into().unwrap(); __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_26, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_25, __v_27, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = result.output.try_into().unwrap(); __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_25, __v_27, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_17 + __v_29); let __v_31: G = G::from_u64(1); @@ -51265,31 +51125,31 @@ fn aiur_fn_587( let __v_36: G = (__v_30 - __v_35); let __v_37: G = (__v_6 + __v_12); let __v_38: G = (__v_36 - __v_37); - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = result.output.try_into().unwrap(); __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_40, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_34, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = result.output.try_into().unwrap(); __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_38, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_48, __v_29, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = result.output.try_into().unwrap(); __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_48, __v_29, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(3); let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 4] = [__v_51, __v_45, __v_50, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_53, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = result.output.try_into().unwrap(); __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_53, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(1); let __v_57: G = (__v_10 + __v_56); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = result.output.try_into().unwrap(); __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_587] = [__v_59]; @@ -51353,7 +51213,7 @@ fn aiur_fn_588( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_4, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; match __v_40.as_canonical_u64() { 1u64 => { @@ -51363,7 +51223,7 @@ fn aiur_fn_588( }, 0u64 => { let __v_41: G = G::from_u64(0); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_588] = []; record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51419,7 +51279,7 @@ fn aiur_fn_589( let __v_22: G = __loaded[10]; match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_22, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_8 - __v_0); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); @@ -51431,18 +51291,18 @@ fn aiur_fn_589( if (__v_15 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); } - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_14, __v_2, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = result.output.try_into().unwrap(); __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_14, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_29: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; let __v_33: G = (__v_15 + __v_16); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_30, __v_31, __v_32, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_30, __v_31, __v_32, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); if (__v_37 != __v_38) { @@ -51450,7 +51310,7 @@ fn aiur_fn_589( } let __v_39: G = G::from_u64(1); let __v_40: G = (__v_8 + __v_39); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_589] = []; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51458,7 +51318,7 @@ fn aiur_fn_589( 0u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = (__v_8 + __v_29); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_589] = []; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51471,7 +51331,7 @@ fn aiur_fn_589( _ => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_8 + __v_23); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = result.output.try_into().unwrap(); __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_589] = []; record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51503,7 +51363,7 @@ fn aiur_fn_590( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = result.output.try_into().unwrap(); __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_590] = []; record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51547,7 +51407,7 @@ fn aiur_fn_591( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = result.output.try_into().unwrap(); __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { @@ -51557,7 +51417,7 @@ fn aiur_fn_591( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_2 - __v_18); - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = result.output.try_into().unwrap(); __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_591] = []; record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -51822,7 +51682,7 @@ fn aiur_fn_601( _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_601] = [__v_9]; record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -51851,18 +51711,18 @@ fn aiur_fn_602( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = result.output.try_into().unwrap(); __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_602] = [__v_8, __v_9]; @@ -51870,7 +51730,7 @@ fn aiur_fn_602( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_602] = [__v_7, __v_8]; @@ -51882,7 +51742,7 @@ fn aiur_fn_602( _ => { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_602] = [__v_7, __v_8]; @@ -51890,7 +51750,7 @@ fn aiur_fn_602( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __ret: [G; OUT_602] = [__v_7, __v_8]; @@ -51953,7 +51813,7 @@ fn aiur_fn_603( let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_603] = [__v_12]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -51998,11 +51858,11 @@ fn aiur_fn_603( let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_603] = [__v_20]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52053,11 +51913,11 @@ fn aiur_fn_603( let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_603] = [__v_20]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52077,7 +51937,7 @@ fn aiur_fn_603( 4u64 => { match __v_3.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_603] = [__v_6]; record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52156,11 +52016,11 @@ fn aiur_fn_604( let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_5, __v_6, __v_7, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_5, __v_6, __v_7, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_604] = [__v_16]; record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52190,9 +52050,9 @@ fn aiur_fn_605( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_605] = [__v_3, __v_4]; @@ -52232,7 +52092,7 @@ fn aiur_fn_606( let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = result.output.try_into().unwrap(); __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_606] = [__v_11]; record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52264,7 +52124,7 @@ fn aiur_fn_607( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_8]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52295,7 +52155,7 @@ fn aiur_fn_607( let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_14]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52324,11 +52184,11 @@ fn aiur_fn_607( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = result.output.try_into().unwrap(); __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_10]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52363,11 +52223,11 @@ fn aiur_fn_607( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_10]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52408,11 +52268,11 @@ fn aiur_fn_607( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_10]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52459,11 +52319,11 @@ fn aiur_fn_607( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_10]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52516,15 +52376,15 @@ fn aiur_fn_607( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_12]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52547,7 +52407,7 @@ fn aiur_fn_607( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = result.output.try_into().unwrap(); __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_8]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52564,15 +52424,15 @@ fn aiur_fn_607( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_607] = [__v_12]; record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -52609,7 +52469,7 @@ fn aiur_fn_608( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = result.output.try_into().unwrap(); __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_608] = [__v_4, __v_5]; @@ -52627,7 +52487,7 @@ fn aiur_fn_608( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = result.output.try_into().unwrap(); __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_608] = [__v_12, __v_13]; @@ -52661,9 +52521,9 @@ fn aiur_fn_609( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_10, __v_11]; @@ -52671,7 +52531,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52687,7 +52547,7 @@ fn aiur_fn_609( let __v_11: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_12, __v_13]; @@ -52699,9 +52559,9 @@ fn aiur_fn_609( let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = result.output.try_into().unwrap(); __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_16, __v_17]; @@ -52709,7 +52569,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_12, __v_13]; @@ -52721,7 +52581,7 @@ fn aiur_fn_609( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52729,7 +52589,7 @@ fn aiur_fn_609( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52737,13 +52597,13 @@ fn aiur_fn_609( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = result.output.try_into().unwrap(); __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = result.output.try_into().unwrap(); __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_13, __v_14]; @@ -52751,7 +52611,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52763,7 +52623,7 @@ fn aiur_fn_609( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52771,7 +52631,7 @@ fn aiur_fn_609( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52779,7 +52639,7 @@ fn aiur_fn_609( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52787,13 +52647,13 @@ fn aiur_fn_609( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_13, __v_14]; @@ -52801,7 +52661,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52813,7 +52673,7 @@ fn aiur_fn_609( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52821,7 +52681,7 @@ fn aiur_fn_609( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52829,7 +52689,7 @@ fn aiur_fn_609( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52837,7 +52697,7 @@ fn aiur_fn_609( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52845,13 +52705,13 @@ fn aiur_fn_609( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_13, __v_14]; @@ -52859,7 +52719,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52871,7 +52731,7 @@ fn aiur_fn_609( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52879,7 +52739,7 @@ fn aiur_fn_609( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52887,7 +52747,7 @@ fn aiur_fn_609( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52895,7 +52755,7 @@ fn aiur_fn_609( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52903,7 +52763,7 @@ fn aiur_fn_609( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52911,13 +52771,13 @@ fn aiur_fn_609( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_13, __v_14]; @@ -52925,7 +52785,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52937,7 +52797,7 @@ fn aiur_fn_609( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52945,7 +52805,7 @@ fn aiur_fn_609( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52953,7 +52813,7 @@ fn aiur_fn_609( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52961,7 +52821,7 @@ fn aiur_fn_609( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52969,7 +52829,7 @@ fn aiur_fn_609( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52977,7 +52837,7 @@ fn aiur_fn_609( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -52985,19 +52845,19 @@ fn aiur_fn_609( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_17, __v_18]; @@ -53005,7 +52865,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -53017,7 +52877,7 @@ fn aiur_fn_609( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -53025,9 +52885,9 @@ fn aiur_fn_609( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = result.output.try_into().unwrap(); __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_10, __v_11]; @@ -53035,7 +52895,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -53047,21 +52907,21 @@ fn aiur_fn_609( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = result.output.try_into().unwrap(); __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_18, __v_19]; @@ -53069,7 +52929,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_609] = [__v_9, __v_10]; @@ -53103,7 +52963,7 @@ fn aiur_fn_610( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = result.output.try_into().unwrap(); __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_610] = [__v_4]; record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53129,7 +52989,7 @@ fn aiur_fn_610( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = result.output.try_into().unwrap(); __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_610] = [__v_4]; record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53159,19 +53019,19 @@ fn aiur_fn_611( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = result.output.try_into().unwrap(); __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = result.output.try_into().unwrap(); __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_611] = [__v_7]; record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53230,11 +53090,11 @@ fn aiur_fn_612( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = result.output.try_into().unwrap(); __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = result.output.try_into().unwrap(); __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_24]; record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53278,35 +53138,35 @@ fn aiur_fn_613( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_7, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_21, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_20, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_19, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_17, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_16, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_613] = [__v_30]; record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53364,11 +53224,11 @@ fn aiur_fn_614( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = result.output.try_into().unwrap(); __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_614] = [__v_10]; record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53406,15 +53266,15 @@ fn aiur_fn_615( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_615] = [__v_10]; record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53482,11 +53342,11 @@ fn aiur_fn_616( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = result.output.try_into().unwrap(); __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = result.output.try_into().unwrap(); __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_616] = [__v_14]; record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53525,23 +53385,23 @@ fn aiur_fn_617( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_9, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_9, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_617] = [__v_17, __v_18]; @@ -53583,7 +53443,7 @@ fn aiur_fn_618( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = result.output.try_into().unwrap(); __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_618] = [__v_13, __v_14]; @@ -53591,7 +53451,7 @@ fn aiur_fn_618( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = result.output.try_into().unwrap(); __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_618] = [__v_13, __v_14]; @@ -53609,7 +53469,7 @@ fn aiur_fn_618( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = result.output.try_into().unwrap(); __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_618] = [__v_13, __v_14]; @@ -53617,13 +53477,13 @@ fn aiur_fn_618( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = result.output.try_into().unwrap(); __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_12, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = result.output.try_into().unwrap(); __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_618] = [__v_17, __v_18]; @@ -53751,15 +53611,15 @@ fn aiur_fn_620( let __v_19: G = inp[19]; let __v_20: G = inp[20]; let __v_21: G = inp[21]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = result.output.try_into().unwrap(); __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_620] = [__v_25]; record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53810,15 +53670,15 @@ fn aiur_fn_621( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_26]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53832,15 +53692,15 @@ fn aiur_fn_621( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_26]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53854,19 +53714,19 @@ fn aiur_fn_621( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_28]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53880,11 +53740,11 @@ fn aiur_fn_621( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_24]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53898,15 +53758,15 @@ fn aiur_fn_621( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_26]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53920,35 +53780,35 @@ fn aiur_fn_621( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_27, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_36]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53962,23 +53822,23 @@ fn aiur_fn_621( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_30]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -53992,35 +53852,35 @@ fn aiur_fn_621( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = result.output.try_into().unwrap(); __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = result.output.try_into().unwrap(); __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_27, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = result.output.try_into().unwrap(); __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_36]; record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -54071,15 +53931,15 @@ fn aiur_fn_622( let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = result.output.try_into().unwrap(); __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_622] = [__v_26, __v_27]; @@ -54087,7 +53947,7 @@ fn aiur_fn_622( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_622] = [__v_26, __v_27]; @@ -54135,21 +53995,21 @@ fn aiur_fn_623( 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_32, __v_33]; @@ -54164,21 +54024,21 @@ fn aiur_fn_623( 2u64 => { match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_32, __v_33]; @@ -54193,29 +54053,29 @@ fn aiur_fn_623( 3u64 => { match __v_11.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_28, __v_29, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_28, __v_29, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_37, __v_38]; @@ -54230,15 +54090,15 @@ fn aiur_fn_623( 4u64 => { match __v_11.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_28, __v_29]; @@ -54253,23 +54113,23 @@ fn aiur_fn_623( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_29, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_33, __v_34]; @@ -54284,59 +54144,59 @@ fn aiur_fn_623( 5u64 => { match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_38, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_55, __v_56]; @@ -54351,39 +54211,39 @@ fn aiur_fn_623( 6u64 => { match __v_11.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_37, __v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_39, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_41, __v_42]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_43, __v_44]; @@ -54398,61 +54258,61 @@ fn aiur_fn_623( 7u64 => { match __v_11.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = result.output.try_into().unwrap(); __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_38]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = result.output.try_into().unwrap(); __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = result.output.try_into().unwrap(); __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_18, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = result.output.try_into().unwrap(); __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_18, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_39, __v_40, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_39, __v_40, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = result.output.try_into().unwrap(); __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __ret: [G; OUT_623] = [__v_57, __v_58]; @@ -54511,13 +54371,13 @@ fn aiur_fn_624( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = result.output.try_into().unwrap(); __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = (__v_3 + __v_19); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = result.output.try_into().unwrap(); __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -54592,7 +54452,7 @@ fn aiur_fn_625( let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_33, __v_36, __v_37, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_33, __v_36, __v_37, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_625] = []; record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -54628,7 +54488,7 @@ fn aiur_fn_626( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -54756,7 +54616,7 @@ fn aiur_fn_627( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = result.output.try_into().unwrap(); __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_627] = []; record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -54774,28 +54634,28 @@ fn aiur_fn_627( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = result.output.try_into().unwrap(); __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_627] = []; record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = result.output.try_into().unwrap(); __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_19, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = result.output.try_into().unwrap(); __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_3 + __v_22); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = result.output.try_into().unwrap(); __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_627] = []; record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -54857,7 +54717,7 @@ fn aiur_fn_628( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 1u64 => { @@ -54931,7 +54791,7 @@ fn aiur_fn_629( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; match __v_36.as_canonical_u64() { 1u64 => { @@ -54940,7 +54800,7 @@ fn aiur_fn_629( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { 0u64 => { @@ -54954,7 +54814,7 @@ fn aiur_fn_629( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = result.output.try_into().unwrap(); __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_629] = []; record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -54980,9 +54840,9 @@ fn aiur_fn_630( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = result.output.try_into().unwrap(); __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { @@ -54996,13 +54856,13 @@ fn aiur_fn_630( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = result.output.try_into().unwrap(); __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = result.output.try_into().unwrap(); __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_6, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_5 != __v_8) { @@ -55046,7 +54906,7 @@ fn aiur_fn_631( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -55060,9 +54920,9 @@ fn aiur_fn_631( let __v_14: G = __loaded[8]; let __v_15: G = __loaded[9]; let __v_16: G = __loaded[10]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = result.output.try_into().unwrap(); __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = result.output.try_into().unwrap(); __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -55109,11 +54969,11 @@ fn aiur_fn_632( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = result.output.try_into().unwrap(); __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_632] = [__v_5]; record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55159,9 +55019,9 @@ fn aiur_fn_633( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_633] = [__v_5]; record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55192,7 +55052,7 @@ fn aiur_fn_634( let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(32); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_6, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = result.output.try_into().unwrap(); __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_634] = [__v_8]; record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55220,11 +55080,11 @@ fn aiur_fn_635( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = result.output.try_into().unwrap(); __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = result.output.try_into().unwrap(); __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = result.output.try_into().unwrap(); __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -55235,7 +55095,7 @@ fn aiur_fn_635( _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_1, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = result.output.try_into().unwrap(); __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_8]; record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55274,11 +55134,11 @@ fn aiur_fn_636( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = result.output.try_into().unwrap(); __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = result.output.try_into().unwrap(); __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_636] = [__v_8]; record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55304,7 +55164,7 @@ fn aiur_fn_637( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { @@ -55326,9 +55186,9 @@ fn aiur_fn_637( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = result.output.try_into().unwrap(); __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = result.output.try_into().unwrap(); __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_637] = [__v_5]; record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55365,9 +55225,9 @@ fn aiur_fn_638( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_5, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = result.output.try_into().unwrap(); __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = result.output.try_into().unwrap(); __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_638] = [__v_7]; record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55410,7 +55270,7 @@ fn aiur_fn_639( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -55424,7 +55284,7 @@ fn aiur_fn_639( let __v_16: G = __loaded[8]; let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -55438,7 +55298,7 @@ fn aiur_fn_639( let __v_28: G = __loaded[8]; let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = result.output.try_into().unwrap(); __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { @@ -55451,7 +55311,7 @@ fn aiur_fn_639( }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = result.output.try_into().unwrap(); __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_639] = [__v_35]; @@ -55499,7 +55359,7 @@ fn aiur_fn_640( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_640] = [__v_11]; record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55543,7 +55403,7 @@ fn aiur_fn_641( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -55557,7 +55417,7 @@ fn aiur_fn_641( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -55571,14 +55431,14 @@ fn aiur_fn_641( let __v_29: G = __loaded[8]; let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = result.output.try_into().unwrap(); __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_641] = [__v_35]; record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55591,7 +55451,7 @@ fn aiur_fn_641( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = result.output.try_into().unwrap(); __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_641] = [__v_41]; @@ -55657,7 +55517,7 @@ fn aiur_fn_642( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = result.output.try_into().unwrap(); __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { @@ -55667,7 +55527,7 @@ fn aiur_fn_642( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = result.output.try_into().unwrap(); __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_642] = [__v_9]; record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55800,7 +55660,7 @@ fn aiur_fn_644( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -55815,7 +55675,7 @@ fn aiur_fn_644( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = result.output.try_into().unwrap(); __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); let __ret: [G; OUT_644] = [__v_20]; @@ -55823,9 +55683,9 @@ fn aiur_fn_644( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __ret: [G; OUT_644] = [__v_8]; @@ -55833,9 +55693,9 @@ fn aiur_fn_644( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __ret: [G; OUT_644] = [__v_8]; @@ -55843,9 +55703,9 @@ fn aiur_fn_644( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __ret: [G; OUT_644] = [__v_8]; @@ -55853,11 +55713,11 @@ fn aiur_fn_644( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 * __v_8); let __v_10: G = (__v_6 * __v_9); @@ -55872,7 +55732,7 @@ fn aiur_fn_644( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_6]; record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -55905,7 +55765,7 @@ fn aiur_fn_645( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = result.output.try_into().unwrap(); __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { @@ -55947,7 +55807,7 @@ fn aiur_fn_646( let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_646] = []; record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -55961,8 +55821,8 @@ fn aiur_fn_646( let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_646] = []; record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -55976,8 +55836,8 @@ fn aiur_fn_646( let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_646] = []; record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56026,8 +55886,8 @@ fn aiur_fn_647( let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = result.output.try_into().unwrap(); __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_647] = []; record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56074,13 +55934,13 @@ fn aiur_fn_648( let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9, __v_10, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = result.output.try_into().unwrap(); __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -56094,49 +55954,49 @@ fn aiur_fn_648( let __v_17: G = __loaded[8]; let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = result.output.try_into().unwrap(); __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_9, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56147,7 +56007,7 @@ fn aiur_fn_648( return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_648] = []; record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56181,36 +56041,36 @@ fn aiur_fn_649( let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = result.output.try_into().unwrap(); __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = result.output.try_into().unwrap(); __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; match __v_0.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_649] = []; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_649] = []; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_649] = []; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = result.output.try_into().unwrap(); __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_649] = []; record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56253,8 +56113,8 @@ fn aiur_fn_650( match __v_4.as_canonical_u64() { _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_8, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = result.output.try_into().unwrap(); __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = result.output.try_into().unwrap(); __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_650] = []; record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56280,12 +56140,12 @@ fn aiur_fn_651( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = result.output.try_into().unwrap(); __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_1, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -56309,20 +56169,20 @@ fn aiur_fn_651( if (__v_9 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = result.output.try_into().unwrap(); __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); } let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = result.output.try_into().unwrap(); __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_23, __v_24]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); if (__v_25 != __v_26) { @@ -56363,17 +56223,17 @@ fn aiur_fn_652( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = result.output.try_into().unwrap(); __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = result.output.try_into().unwrap(); __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56382,14 +56242,14 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56398,7 +56258,7 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; @@ -56406,18 +56266,18 @@ fn aiur_fn_652( let __v_21: G = __loaded[2]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); } - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_28, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_28, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56426,10 +56286,10 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_652] = []; @@ -56440,7 +56300,7 @@ fn aiur_fn_652( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = result.output.try_into().unwrap(); __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56454,12 +56314,12 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = result.output.try_into().unwrap(); __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56468,14 +56328,14 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = result.output.try_into().unwrap(); __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = result.output.try_into().unwrap(); __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_19, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = result.output.try_into().unwrap(); __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_3, __v_19, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = result.output.try_into().unwrap(); __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_19, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_3, __v_19, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; if (__v_6 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); @@ -56488,11 +56348,11 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = result.output.try_into().unwrap(); __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -56511,21 +56371,21 @@ fn aiur_fn_652( if (__v_5 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_22, __v_2, __v_23, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = result.output.try_into().unwrap(); __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = result.output.try_into().unwrap(); __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_22, __v_2, __v_23, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_31: G = (__v_23 + __v_24); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = result.output.try_into().unwrap(); __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 3] = [__v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_5, __v_32, __v_33, __v_34, __v_37, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = result.output.try_into().unwrap(); __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_5, __v_32, __v_33, __v_34, __v_37, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_38: G = G::from_u64(1); let __v_39: G = G::from_u64(1); let __v_40: G = { let __values: [G; 3] = [__v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5, __v_3, __v_40, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = result.output.try_into().unwrap(); __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5, __v_3, __v_40, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56539,10 +56399,10 @@ fn aiur_fn_652( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = result.output.try_into().unwrap(); __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = result.output.try_into().unwrap(); __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = result.output.try_into().unwrap(); __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_652] = []; record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56572,9 +56432,9 @@ fn aiur_fn_653( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = result.output.try_into().unwrap(); __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { @@ -56585,9 +56445,9 @@ fn aiur_fn_653( break '__mc_0 [__v_9, __v_10]; }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = result.output.try_into().unwrap(); __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { @@ -56598,23 +56458,23 @@ fn aiur_fn_653( break '__mc_0 [__v_9, __v_10]; }, 2u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = result.output.try_into().unwrap(); __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); } - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = result.output.try_into().unwrap(); __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_9: G = G::from_u64(2); let __v_10: G = G::from_u64(6); break '__mc_0 [__v_9, __v_10]; }, 3u64 => { - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = result.output.try_into().unwrap(); __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { @@ -56635,7 +56495,7 @@ fn aiur_fn_653( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); } let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = result.output.try_into().unwrap(); __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { @@ -56678,7 +56538,7 @@ fn aiur_fn_654( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_1, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = result.output.try_into().unwrap(); __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_654] = [__v_10]; record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -56709,9 +56569,9 @@ fn aiur_fn_655( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = result.output.try_into().unwrap(); __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = result.output.try_into().unwrap(); __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_655] = []; record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56755,10 +56615,10 @@ fn aiur_fn_656( let __v_15: G = __loaded[8]; let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_3 + __v_18); - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = result.output.try_into().unwrap(); __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_656] = []; record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -56781,7 +56641,7 @@ fn aiur_fn_657( ) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -56793,7 +56653,7 @@ fn aiur_fn_657( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); @@ -56829,7 +56689,7 @@ fn aiur_fn_658( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -56869,7 +56729,7 @@ fn aiur_fn_659( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); @@ -56902,7 +56762,7 @@ fn aiur_fn_660( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); @@ -56935,7 +56795,7 @@ fn aiur_fn_661( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -56990,7 +56850,7 @@ fn aiur_fn_662( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -57050,7 +56910,7 @@ fn aiur_fn_663( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -57062,7 +56922,7 @@ fn aiur_fn_663( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = result.output.try_into().unwrap(); __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57081,7 +56941,7 @@ fn aiur_fn_663( let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -57090,7 +56950,7 @@ fn aiur_fn_663( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = result.output.try_into().unwrap(); __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); @@ -57124,7 +56984,7 @@ fn aiur_fn_664( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -57134,7 +56994,7 @@ fn aiur_fn_664( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = result.output.try_into().unwrap(); __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); @@ -57157,7 +57017,7 @@ fn aiur_fn_665( ) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -57167,7 +57027,7 @@ fn aiur_fn_665( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_1]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_1).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; let __v_10: G = __b1_out[0]; let __v_11: G = __b1_out[1]; let __v_12: G = __b1_out[2]; @@ -57176,11 +57036,11 @@ fn aiur_fn_665( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_11, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -57191,7 +57051,7 @@ fn aiur_fn_665( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -57202,7 +57062,7 @@ fn aiur_fn_665( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -57213,7 +57073,7 @@ fn aiur_fn_665( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -57224,7 +57084,7 @@ fn aiur_fn_665( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -57245,7 +57105,7 @@ fn aiur_fn_666( ) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -57255,7 +57115,7 @@ fn aiur_fn_666( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = result.output.try_into().unwrap(); __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57322,7 +57182,7 @@ fn aiur_fn_667( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -57334,7 +57194,7 @@ fn aiur_fn_667( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = result.output.try_into().unwrap(); __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57384,7 +57244,7 @@ fn aiur_fn_667( let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -57393,7 +57253,7 @@ fn aiur_fn_667( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = result.output.try_into().unwrap(); __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); @@ -57427,7 +57287,7 @@ fn aiur_fn_668( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -57437,7 +57297,7 @@ fn aiur_fn_668( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = result.output.try_into().unwrap(); __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); @@ -57460,10 +57320,10 @@ fn aiur_fn_669( ) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -57473,7 +57333,7 @@ fn aiur_fn_669( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_3]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_3).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; let __v_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; @@ -57482,7 +57342,7 @@ fn aiur_fn_669( let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_4]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_4).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; let __v_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; @@ -57493,15 +57353,15 @@ fn aiur_fn_669( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57512,11 +57372,11 @@ fn aiur_fn_669( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -57527,19 +57387,19 @@ fn aiur_fn_669( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -57550,7 +57410,7 @@ fn aiur_fn_669( let __v_44: G = __r_arr[7]; let __v_45: G = __r_arr[8]; let __v_46: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -57561,7 +57421,7 @@ fn aiur_fn_669( let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; let __v_56: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -57572,7 +57432,7 @@ fn aiur_fn_669( let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; let __v_66: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_66]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = __r_arr[2]; @@ -57583,11 +57443,11 @@ fn aiur_fn_669( let __v_74: G = __r_arr[7]; let __v_75: G = __r_arr[8]; let __v_76: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; let __v_79: G = __r_arr[2]; - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_20, __v_79]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = result.output.try_into().unwrap(); __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_20, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; let __v_81: G = __r_arr[1]; let __v_82: G = __r_arr[2]; @@ -57598,15 +57458,15 @@ fn aiur_fn_669( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57617,7 +57477,7 @@ fn aiur_fn_669( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -57628,7 +57488,7 @@ fn aiur_fn_669( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -57639,7 +57499,7 @@ fn aiur_fn_669( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -57650,7 +57510,7 @@ fn aiur_fn_669( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -57661,11 +57521,11 @@ fn aiur_fn_669( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = result.output.try_into().unwrap(); __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; @@ -57692,7 +57552,7 @@ fn aiur_fn_670( ) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -57702,7 +57562,7 @@ fn aiur_fn_670( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = result.output.try_into().unwrap(); __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57783,7 +57643,7 @@ fn aiur_fn_671( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -57795,7 +57655,7 @@ fn aiur_fn_671( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = result.output.try_into().unwrap(); __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -57859,7 +57719,7 @@ fn aiur_fn_671( let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; @@ -57868,7 +57728,7 @@ fn aiur_fn_671( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = result.output.try_into().unwrap(); __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); @@ -57892,10 +57752,10 @@ fn aiur_fn_672( ) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -57905,7 +57765,7 @@ fn aiur_fn_672( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_3]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_3).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; let __v_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; @@ -57914,7 +57774,7 @@ fn aiur_fn_672( let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; - let __b1_out: [G; 8] = { let mut __scratch: Vec = vec![__v_4]; if unconstrained { __scratch.extend(Bytes1::bit_decompose(&__v_4).to_vec()); } else { bytes1_execute(0, &Bytes1Op::BitDecomposition, &mut __scratch, record); } let __arr: [G; 8] = __scratch[1..].try_into().unwrap(); __arr }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; let __v_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; @@ -57925,15 +57785,15 @@ fn aiur_fn_672( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = result.output.try_into().unwrap(); __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57944,11 +57804,11 @@ fn aiur_fn_672( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -57959,15 +57819,15 @@ fn aiur_fn_672( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -57978,7 +57838,7 @@ fn aiur_fn_672( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -57989,7 +57849,7 @@ fn aiur_fn_672( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -58000,7 +57860,7 @@ fn aiur_fn_672( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -58011,7 +57871,7 @@ fn aiur_fn_672( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -58022,11 +57882,11 @@ fn aiur_fn_672( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = result.output.try_into().unwrap(); __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; @@ -58036,11 +57896,11 @@ fn aiur_fn_672( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = result.output.try_into().unwrap(); __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -58051,7 +57911,7 @@ fn aiur_fn_672( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -58062,11 +57922,11 @@ fn aiur_fn_672( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = result.output.try_into().unwrap(); __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -58077,7 +57937,7 @@ fn aiur_fn_672( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -58088,7 +57948,7 @@ fn aiur_fn_672( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58099,7 +57959,7 @@ fn aiur_fn_672( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -58110,7 +57970,7 @@ fn aiur_fn_672( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -58121,7 +57981,7 @@ fn aiur_fn_672( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58132,7 +57992,7 @@ fn aiur_fn_672( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -58143,7 +58003,7 @@ fn aiur_fn_672( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58154,7 +58014,7 @@ fn aiur_fn_672( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -58165,7 +58025,7 @@ fn aiur_fn_672( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = result.output.try_into().unwrap(); __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58176,7 +58036,7 @@ fn aiur_fn_672( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = result.output.try_into().unwrap(); __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -58195,7 +58055,7 @@ fn aiur_fn_672( break '__mc_0 [__v_30, __v_11]; }, 1u64 => { - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = result.output.try_into().unwrap(); __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -58205,7 +58065,7 @@ fn aiur_fn_672( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = result.output.try_into().unwrap(); __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -58241,7 +58101,7 @@ fn aiur_fn_673( ) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -58258,13 +58118,13 @@ fn aiur_fn_673( } match __v_2.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -58275,10 +58135,10 @@ fn aiur_fn_673( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -58289,10 +58149,10 @@ fn aiur_fn_673( return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = result.output.try_into().unwrap(); __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -58303,10 +58163,10 @@ fn aiur_fn_673( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = result.output.try_into().unwrap(); __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -58368,10 +58228,10 @@ fn aiur_fn_673( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = G::from_u64(4); @@ -58434,9 +58294,9 @@ fn aiur_fn_674( let __v_33: G = __io_pair.0; let __v_34: G = __io_pair.1; let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = result.output.try_into().unwrap(); __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -58548,9 +58408,9 @@ fn aiur_fn_675( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = result.output.try_into().unwrap(); __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_22]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_23]; record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -58615,9 +58475,9 @@ fn aiur_fn_677( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = result.output.try_into().unwrap(); __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = result.output.try_into().unwrap(); __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); @@ -58653,9 +58513,9 @@ fn aiur_fn_678( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = result.output.try_into().unwrap(); __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); @@ -58987,7 +58847,7 @@ fn aiur_fn_682( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = result.output.try_into().unwrap(); __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -59263,8 +59123,8 @@ fn aiur_fn_683( return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_32, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_31, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = result.output.try_into().unwrap(); __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_32, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_31, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_683] = []; record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59305,7 +59165,7 @@ fn aiur_fn_684( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = result.output.try_into().unwrap(); __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_684] = []; record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59376,7 +59236,7 @@ fn aiur_fn_685( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = result.output.try_into().unwrap(); __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -59415,12 +59275,12 @@ fn aiur_fn_685( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_49, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_82, __v_47, __v_48]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_685] = []; record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59501,8 +59361,8 @@ fn aiur_fn_686( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = result.output.try_into().unwrap(); __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = result.output.try_into().unwrap(); __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_686] = []; record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59534,7 +59394,7 @@ fn aiur_fn_687( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = result.output.try_into().unwrap(); __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_687] = []; record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59661,11 +59521,11 @@ fn aiur_fn_688( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_11, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_12, __v_61, __v_62]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_688] = []; record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59682,15 +59542,15 @@ fn aiur_fn_688( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_3, __v_50, __v_51]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_36, __v_88, __v_89]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_37, __v_90, __v_91]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = result.output.try_into().unwrap(); __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_3, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_36, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_37, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_688] = []; record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59707,15 +59567,15 @@ fn aiur_fn_688( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_43, __v_95, __v_96]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_44, __v_97, __v_98]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = result.output.try_into().unwrap(); __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_688] = []; record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59818,7 +59678,7 @@ fn aiur_fn_689( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = result.output.try_into().unwrap(); __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -59864,8 +59724,8 @@ fn aiur_fn_689( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = result.output.try_into().unwrap(); __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = result.output.try_into().unwrap(); __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_689] = []; record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -59891,12 +59751,12 @@ fn aiur_fn_690( let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_690] = [__v_8]; record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -59919,14 +59779,14 @@ fn aiur_fn_691( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_1, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = result.output.try_into().unwrap(); __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = result.output.try_into().unwrap(); __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_691] = [__v_10]; record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -59945,15 +59805,15 @@ fn aiur_fn_692( ) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = result.output.try_into().unwrap(); __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = result.output.try_into().unwrap(); __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = result.output.try_into().unwrap(); __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); @@ -60006,17 +59866,17 @@ fn aiur_fn_692( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = result.output.try_into().unwrap(); __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_692] = [__v_9, __v_10, __v_8]; record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -60078,9 +59938,9 @@ fn aiur_fn_693( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = result.output.try_into().unwrap(); __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -60099,7 +59959,7 @@ fn aiur_fn_693( if (__v_39 != __v_49) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); } - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = result.output.try_into().unwrap(); __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -60277,7 +60137,7 @@ fn aiur_fn_694( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -60287,7 +60147,7 @@ fn aiur_fn_694( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = result.output.try_into().unwrap(); __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_694] = [__v_6]; record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -60389,16 +60249,16 @@ fn aiur_fn_696( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = result.output.try_into().unwrap(); __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = result.output.try_into().unwrap(); __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = result.output.try_into().unwrap(); __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -60433,7 +60293,7 @@ fn aiur_fn_697( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = result.output.try_into().unwrap(); __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); @@ -60468,9 +60328,9 @@ fn aiur_fn_697( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_41, __v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = result.output.try_into().unwrap(); __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_41, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_42]; record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -60492,10 +60352,10 @@ fn aiur_fn_698( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = result.output.try_into().unwrap(); __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = result.output.try_into().unwrap(); __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -60503,7 +60363,7 @@ fn aiur_fn_698( let __v_10: G = __r_arr[4]; let __v_11: G = __r_arr[5]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_698] = []; record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60553,24 +60413,24 @@ fn aiur_fn_699( let __v_21: G = __loaded[8]; let __v_22: G = __loaded[9]; let __v_23: G = __loaded[10]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = result.output.try_into().unwrap(); __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_699] = []; record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = result.output.try_into().unwrap(); __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_699] = []; record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60597,20 +60457,20 @@ fn aiur_fn_700( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = result.output.try_into().unwrap(); __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = result.output.try_into().unwrap(); __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_700] = []; record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = result.output.try_into().unwrap(); __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_700] = []; record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60634,9 +60494,9 @@ fn aiur_fn_701( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = result.output.try_into().unwrap(); __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { @@ -60661,22 +60521,22 @@ fn aiur_fn_702( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = result.output.try_into().unwrap(); __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = result.output.try_into().unwrap(); __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_702] = []; record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = result.output.try_into().unwrap(); __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = result.output.try_into().unwrap(); __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_702] = []; record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60753,7 +60613,7 @@ fn aiur_fn_703( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = result.output.try_into().unwrap(); __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -60810,11 +60670,11 @@ fn aiur_fn_703( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_57, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = result.output.try_into().unwrap(); __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_66, __v_15, __v_16]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_67, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60831,15 +60691,15 @@ fn aiur_fn_703( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_57, __v_4, __v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_98, __v_51, __v_52]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_99, __v_53, __v_54]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = result.output.try_into().unwrap(); __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60856,9 +60716,9 @@ fn aiur_fn_703( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = result.output.try_into().unwrap(); __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60875,9 +60735,9 @@ fn aiur_fn_703( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = result.output.try_into().unwrap(); __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = result.output.try_into().unwrap(); __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60894,9 +60754,9 @@ fn aiur_fn_703( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_72, __v_20, __v_21]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60913,8 +60773,8 @@ fn aiur_fn_703( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60931,8 +60791,8 @@ fn aiur_fn_703( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60949,8 +60809,8 @@ fn aiur_fn_703( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = result.output.try_into().unwrap(); __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = result.output.try_into().unwrap(); __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -60965,7 +60825,7 @@ fn aiur_fn_703( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = result.output.try_into().unwrap(); __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61051,7 +60911,7 @@ fn aiur_fn_705( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = result.output.try_into().unwrap(); __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -61110,31 +60970,31 @@ fn aiur_fn_705( let __v_87: G = __r_arr[55]; match __v_32.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = result.output.try_into().unwrap(); __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = result.output.try_into().unwrap(); __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_33, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = result.output.try_into().unwrap(); __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = result.output.try_into().unwrap(); __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = result.output.try_into().unwrap(); __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61189,13 +61049,13 @@ fn aiur_fn_706( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_32]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = result.output.try_into().unwrap(); __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_32, __v_34, __v_35]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = result.output.try_into().unwrap(); __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_32, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_33, __v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = result.output.try_into().unwrap(); __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -61209,7 +61069,7 @@ fn aiur_fn_706( let __v_46: G = __loaded[8]; let __v_47: G = __loaded[9]; let __v_48: G = __loaded[10]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = result.output.try_into().unwrap(); __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_706] = []; record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61241,9 +61101,9 @@ fn aiur_fn_707( let __v_4: G = __io_pair.0; let __v_5: G = __io_pair.1; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -61311,12 +61171,12 @@ fn aiur_fn_707( let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(1); let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; if (__v_7 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); } - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = result.output.try_into().unwrap(); __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_707] = []; record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61340,7 +61200,7 @@ fn aiur_fn_708( let __v_2: G = G::from_u64(4); let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -61352,7 +61212,7 @@ fn aiur_fn_708( let __v_10: G = G::from_u64(4); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { @@ -61364,7 +61224,7 @@ fn aiur_fn_708( let __v_18: G = G::from_u64(4); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); if (__v_21 != __v_22) { @@ -61382,7 +61242,7 @@ fn aiur_fn_708( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 3] = [__v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_23, __v_27, __v_28, __v_29, __v_33, __v_34]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_23, __v_27, __v_28, __v_29, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); if (__v_35 != __v_36) { @@ -61397,7 +61257,7 @@ fn aiur_fn_708( let __v_43: G = G::from_u64(4); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_37, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_37, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(0); if (__v_46 != __v_47) { @@ -61412,7 +61272,7 @@ fn aiur_fn_708( let __v_54: G = G::from_u64(0); let __v_55: G = { let __values: [G; 3] = [__v_52, __v_53, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_48, __v_49, __v_50, __v_51, __v_55, __v_56]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_48, __v_49, __v_50, __v_51, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(1); if (__v_57 != __v_58) { @@ -61427,7 +61287,7 @@ fn aiur_fn_708( let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 3] = [__v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); if (__v_68 != __v_69) { @@ -61436,7 +61296,7 @@ fn aiur_fn_708( let __v_70: G = G::from_u64(4); let __v_71: G = G::from_u64(0); let __v_72: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_70, __v_71, __v_72, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_70, __v_71, __v_72, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { @@ -61445,7 +61305,7 @@ fn aiur_fn_708( let __v_75: G = G::from_u64(4); let __v_76: G = G::from_u64(0); let __v_77: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_75, __v_76, __v_77]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_75, __v_76, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; let __v_79: G = G::from_u64(0); if (__v_78 != __v_79) { @@ -61460,13 +61320,13 @@ fn aiur_fn_708( let __v_86: G = G::from_u64(1); let __v_87: G = G::from_u64(0); let __v_88: G = { let __values: [G; 3] = [__v_85, __v_86, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_80, __v_84, __v_88, __v_59, __v_63, __v_67]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_80, __v_84, __v_88, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_89: G = __r_arr[0]; let __v_90: G = G::from_u64(1); if (__v_89 != __v_90) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64() }); } - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_80, __v_84, __v_88]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = result.output.try_into().unwrap(); __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_80, __v_84, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(0); if (__v_91 != __v_92) { @@ -61498,7 +61358,7 @@ fn aiur_fn_708( let __v_116: G = G::from_u64(0); let __v_117: G = { let __values: [G; 3] = [__v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_118: G = { let __values: [G; 3] = [__v_106, __v_113, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_93, __v_97, __v_98, __v_99, __v_105, __v_118]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_93, __v_97, __v_98, __v_99, __v_105, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = G::from_u64(1); if (__v_119 != __v_120) { @@ -61516,7 +61376,7 @@ fn aiur_fn_708( let __v_130: G = G::from_u64(4); let __v_131: G = G::from_u64(0); let __v_132: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_121, __v_125, __v_129, __v_130, __v_131, __v_132]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_121, __v_125, __v_129, __v_130, __v_131, __v_132]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_133: G = __r_arr[0]; let __v_134: G = G::from_u64(1); if (__v_133 != __v_134) { @@ -61533,7 +61393,7 @@ fn aiur_fn_708( let __v_143: G = G::from_u64(4); let __v_144: G = G::from_u64(0); let __v_145: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_135, __v_139, __v_142, __v_143, __v_144, __v_145]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = result.output.try_into().unwrap(); __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_135, __v_139, __v_142, __v_143, __v_144, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; let __v_147: G = G::from_u64(1); if (__v_146 != __v_147) { @@ -61548,7 +61408,7 @@ fn aiur_fn_708( let __v_154: G = G::from_u64(4); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_154, __v_155, __v_156, __v_148, __v_152, __v_153]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_154, __v_155, __v_156, __v_148, __v_152, __v_153]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; let __v_159: G = __r_arr[2]; @@ -61558,7 +61418,7 @@ fn aiur_fn_708( let __v_163: G = G::from_u64(0); let __v_164: G = { let __values: [G; 3] = [__v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_165: G = { let __values: [G; 3] = [__v_148, __v_152, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_157, __v_158, __v_159, __v_160, __v_164, __v_165]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_157, __v_158, __v_159, __v_160, __v_164, __v_165]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_166: G = __r_arr[0]; let __v_167: G = G::from_u64(1); if (__v_166 != __v_167) { @@ -61569,13 +61429,13 @@ fn aiur_fn_708( let __v_170: G = G::from_u64(0); let __v_171: G = G::from_u64(0); let __v_172: G = G::from_u64(0); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_168, __v_169, __v_170, __v_171, __v_172, __v_172]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = result.output.try_into().unwrap(); __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_168, __v_169, __v_170, __v_171, __v_172, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_173: G = __r_arr[0]; let __v_174: G = __r_arr[1]; let __v_175: G = __r_arr[2]; let __v_176: G = G::from_u64(0); let __v_177: G = G::from_u64(0); - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_173, __v_174, __v_175, __v_176, __v_177, __v_177]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = result.output.try_into().unwrap(); __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_173, __v_174, __v_175, __v_176, __v_177, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; let __v_179: G = G::from_u64(1); if (__v_178 != __v_179) { @@ -61597,7 +61457,7 @@ fn aiur_fn_709( unconstrained: bool, ) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = []; let __cu = unconstrained || false; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = result.output.try_into().unwrap(); __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_709] = []; record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61629,9 +61489,9 @@ fn aiur_fn_710( let __v_4: G = __io_pair.0; let __v_5: G = __io_pair.1; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = unconstrained || true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained && !true { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = result.output.try_into().unwrap(); __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = result.output.try_into().unwrap(); __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -61699,9 +61559,9 @@ fn aiur_fn_710( let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(1); let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = result.output.try_into().unwrap(); __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -61734,7 +61594,7 @@ fn aiur_fn_710( let __v_95: G = __r_arr[29]; let __v_96: G = __r_arr[30]; let __v_97: G = __r_arr[31]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_65]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = result.output.try_into().unwrap(); __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = __r_arr[2]; @@ -61863,7 +61723,7 @@ fn aiur_fn_710( if (__v_97 != __v_129) { return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() }); } - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = result.output.try_into().unwrap(); __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_710] = []; record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); @@ -61901,7 +61761,7 @@ fn aiur_fn_711( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = result.output.try_into().unwrap(); __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_711] = [__v_7]; @@ -61952,7 +61812,7 @@ fn aiur_fn_712( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = result.output.try_into().unwrap(); __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -61961,7 +61821,7 @@ fn aiur_fn_712( let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -62011,7 +61871,7 @@ fn aiur_fn_713( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = result.output.try_into().unwrap(); __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -62020,7 +61880,7 @@ fn aiur_fn_713( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -62064,7 +61924,7 @@ fn aiur_fn_714( }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = result.output.try_into().unwrap(); __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_714] = [__v_7]; @@ -62120,7 +61980,7 @@ fn aiur_fn_715( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_715] = [__v_21]; record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62135,7 +61995,7 @@ fn aiur_fn_715( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = result.output.try_into().unwrap(); __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_715] = [__v_22]; record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62166,7 +62026,7 @@ fn aiur_fn_716( let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = result.output.try_into().unwrap(); __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_716] = [__v_4]; record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62237,7 +62097,7 @@ fn aiur_fn_717( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = result.output.try_into().unwrap(); __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -62246,7 +62106,7 @@ fn aiur_fn_717( let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -62278,7 +62138,7 @@ fn aiur_fn_718( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -62323,7 +62183,7 @@ fn aiur_fn_719( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = result.output.try_into().unwrap(); __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); @@ -62363,7 +62223,7 @@ fn aiur_fn_720( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -62372,7 +62232,7 @@ fn aiur_fn_720( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -62381,7 +62241,7 @@ fn aiur_fn_720( let __v_18: G = __r_arr[5]; let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = result.output.try_into().unwrap(); __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_720] = [__v_21]; record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62429,7 +62289,7 @@ fn aiur_fn_721( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = result.output.try_into().unwrap(); __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); @@ -62480,7 +62340,7 @@ fn aiur_fn_722( let __v_19: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_20]; record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62495,7 +62355,7 @@ fn aiur_fn_722( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = result.output.try_into().unwrap(); __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_722] = [__v_21]; record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -62581,7 +62441,7 @@ fn aiur_fn_723( let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { @@ -62590,7 +62450,7 @@ fn aiur_fn_723( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -62599,7 +62459,7 @@ fn aiur_fn_723( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = result.output.try_into().unwrap(); __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -62688,7 +62548,7 @@ fn aiur_fn_724( }, 0u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = result.output.try_into().unwrap(); __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_724] = [__v_10]; @@ -62776,7 +62636,7 @@ fn aiur_fn_725( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = result.output.try_into().unwrap(); __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -62785,7 +62645,7 @@ fn aiur_fn_725( let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -62843,7 +62703,7 @@ fn aiur_fn_726( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = result.output.try_into().unwrap(); __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -62852,7 +62712,7 @@ fn aiur_fn_726( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = result.output.try_into().unwrap(); __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -62897,7 +62757,7 @@ fn aiur_fn_727( }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = result.output.try_into().unwrap(); __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_727] = [__v_8]; @@ -62969,7 +62829,7 @@ fn aiur_fn_728( let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = result.output.try_into().unwrap(); __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -62978,7 +62838,7 @@ fn aiur_fn_728( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = result.output.try_into().unwrap(); __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -62987,7 +62847,7 @@ fn aiur_fn_728( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = result.output.try_into().unwrap(); __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -63085,7 +62945,7 @@ fn aiur_fn_730( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = result.output.try_into().unwrap(); __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -63137,7 +62997,7 @@ fn aiur_fn_731( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = result.output.try_into().unwrap(); __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_731] = [__v_9]; @@ -63209,7 +63069,7 @@ fn aiur_fn_732( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_36]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = result.output.try_into().unwrap(); __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); @@ -63245,7 +63105,7 @@ fn aiur_fn_733( _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = result.output.try_into().unwrap(); __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -63291,7 +63151,7 @@ fn aiur_fn_734( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = result.output.try_into().unwrap(); __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); @@ -63324,7 +63184,7 @@ fn aiur_fn_735( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -63372,7 +63232,7 @@ fn aiur_fn_736( }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_6, __v_1]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = result.output.try_into().unwrap(); __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_736] = [__v_9]; @@ -63429,7 +63289,7 @@ fn aiur_fn_737( }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = result.output.try_into().unwrap(); __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_737] = [__v_21]; @@ -63468,7 +63328,7 @@ fn aiur_fn_738( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4, __v_6]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = result.output.try_into().unwrap(); __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_738] = [__v_7]; record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); @@ -63502,7 +63362,7 @@ fn aiur_fn_739( _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_3]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = result.output.try_into().unwrap(); __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -63575,14 +63435,14 @@ fn aiur_fn_740( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = result.output.try_into().unwrap(); __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -63605,14 +63465,14 @@ fn aiur_fn_740( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = result.output.try_into().unwrap(); __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = result.output.try_into().unwrap(); __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -63661,7 +63521,7 @@ fn aiur_fn_741( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained || false; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained && !false { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = result.output.try_into().unwrap(); __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; From d02ba46b846b62a73f4400a17c9156c727cfc53b Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 12:00:36 -0700 Subject: [PATCH 08/11] Wire Rust witness fast path through every check/prove entry point MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per-claim mode (a `Claim.check addr none`) builds a closure rooted at the target address. That closure can be the whole environment when the target is a heavily-shared root constant. The Lean witness builder paid per-byte boxing into `Aiur.G` for every byte in that closure — the same cost we already eliminated for shard mode. # Surface Five new FFIs, all bundling witness build + execute_ixvm (and STARK prove where applicable) into one cross-language trip so the `IOBuffer` never crosses the boundary mid-pipeline: * `rs_aiur_toplevel_check_addr_ixvm` — `Bytecode.Toplevel.checkAddrIxVM (toplevel) (funIdx) (ixePath) (addrBytes)`: per-claim check; builds witness for `Claim.check addr none` via `build_claim_check_witness`, runs `execute_ixvm`. Same return shape as `shardCheckIxVM`. * `rs_aiur_toplevel_check_env_bytes_ixvm` — same as above but takes the env as a serialized byte blob (`Ixon.serEnv`) instead of a `.ixe` path. Used by the compiled-Lean-env code path (`ix check NAME` without `--ixe`), where the env is built in Lean memory. * `rs_aiur_system_prove_addr_ixvm` — `AiurSystem.proveAddrIxVM (...)`: per-claim prove (witness + execute + STARK prove all in Rust). * `rs_aiur_system_prove_env_bytes_ixvm` — bytes-blob counterpart. * `rs_aiur_system_shard_prove_ixvm` — `AiurSystem.shardProveIxVM (...)`: per-shard prove end-to-end in Rust. `build_claim_check_witness` lives next to `build_shard_check_env_witness` in `src/ix/aiur_ixvm_witness.rs` and uses the same parallel closure walk + parallel byte→G conversion. The bytes-blob FFIs additionally harvest `anon_hints` from each `Def` named entry after `Env::get` — `Env::get` (full form, used by the bytes-blob path) doesn't populate `env.anon_hints` the way `Env::get_anon` does, but the kernel's `verify_claim` reads ch 3 (Defn reducibility hints) so the hints must end up in the env. This mirrors the harvest pass already inside `get_anon` at `src/ix/ixon/serialize.rs:1683`. # Wiring `Ix.Cli.CheckCmd.WitnessSource`: a three-arm discriminated union threaded through `forEachClaim` (the shared check/prove driver): * `.native ixePath addr` — `.ixe`-backed env, Rust mmap. * `.nativeBytes envBytes addr` — Lean-memory env serialized to bytes, Rust decodes via `Env::get`. * `.lean witness` — pre-built `ClaimWitness` (fallback). `runCompiled` and `proveOne` dispatch on the source. # Coverage | Command | Path | |---------------------------------------|-----------------------------------------------| | `ix check NAME --ixe` | **`checkAddrIxVM`** (new) | | `ix check NAME` (no `--ixe`) | **`checkEnvBytesIxVM`** (new) | | `ix check --claim hex --ixe` | `checkAddrIxVM` for `check addr none` | | `ix check --ixes --shard K` | `shardCheckIxVM` (existed) | | `ix check --ixes` | `shardCheckIxVM` (existed) | | `ix prove NAME --ixe` | **`proveAddrIxVM`** (new) | | `ix prove NAME` (no `--ixe`) | **`proveEnvBytesIxVM`** (new) | | `ix prove --ixes --shard K` | **`shardProveIxVM`** (new) | | `ix prove --ixes` | **`shardProveIxVM`** loop (new) | | `Benchmarks/Typecheck.lean` Phase 1 | `checkAddrIxVM` / `executeIxVM` | | `Benchmarks/Typecheck.lean` Phase 2 | `proveAddrIxVM` / `proveIxVM` | | `Benchmarks/IxVM.lean` | `proveIxVM` (was `prove`) | `--interp` route is preserved: it materialises any `WitnessSource` back into a `ClaimWitness` before driving the Aiur source interpreter. `--claim ` over non-`check addr none` variants (`eval` / `reveal` / `contains` / `checkEnv-with-asm`) still uses the Lean witness builder. # Sanity * `ix check Nat.add_comm --ixe init.ixe` (warm): 3.1 s wall, FFT = 23_603_449. * `ix check Nat.add_comm` (compiled env via bytes blob, warm): 2.4 s wall, FFT = 23_603_449. # Known overheads (tracked for a follow-up redesign) * **Per-claim env re-parse on `--ixe + many names`**: each FFI call re-runs `Env::get_anon_mmap` on the same path. Mathlib-scale iteration pays the lazy-index build N times instead of once. * **`--interp + .nativeBytes` round-trip**: Lean serializes the compiled env then `materialise` deserializes it back, just to feed `runInterp`. * **`runShardProveNative` claim reconstruct**: redoes the closure walk + canonical `AssumptionTree` build Lean-side after `shardProveIxVM` already computed the same claim internally. A future `EnvHandle`-based API would close all three: build the env once into a Rust-owned handle, pass the handle to every per-claim/per-shard FFI, and have prove FFIs return the serialized claim bytes. --- Benchmarks/IxVM.lean | 4 +- Benchmarks/Typecheck.lean | 27 +- Ix/Aiur/Protocol.lean | 62 +++++ Ix/Aiur/Semantics/BytecodeFfi.lean | 45 ++++ Ix/Aiur/Stages/Codegen.lean | 16 +- Ix/Cli/CheckCmd.lean | 129 +++++++--- Ix/Cli/CodegenCmd.lean | 8 +- Ix/Cli/ProveCmd.lean | 91 ++++++- crates/ffi/src/aiur/protocol.rs | 389 +++++++++++++++++++++++++++++ crates/ix/src/aiur_ixvm.rs | 2 +- crates/ix/src/aiur_ixvm_witness.rs | 36 +++ 11 files changed, 747 insertions(+), 62 deletions(-) diff --git a/Benchmarks/IxVM.lean b/Benchmarks/IxVM.lean index d38c2ed2..57f39187 100644 --- a/Benchmarks/IxVM.lean +++ b/Benchmarks/IxVM.lean @@ -34,7 +34,9 @@ def main : IO Unit := do let _ ← bgroup "IxVM benchmarks" { oneShot := true } do throughput (.Elements n.toUInt64 "consts") + -- IxVM-native prove: routes execution through the codegen'd Rust + -- kernel (`execute_generated`) instead of the bytecode interpreter. bench "serde/blake3 Nat.add_comm" - (aiurSystem.prove friParameters funIdx #[.ofNat n]) + (aiurSystem.proveIxVM friParameters funIdx #[.ofNat n]) ioBuffer return diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 1906378b..7bd9cc02 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -188,14 +188,22 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do -- Phase 1: execute every constant (cheap, deterministic structural metrics). -- Carry each target's address through so phase 2 can rebuild its witness. + -- For full-closure check claims (`Claim.check addr none`), use the + -- Rust-native fast path `checkAddrIxVM`: skips per-byte boxing into + -- `Aiur.G` (the dominant cost on heavy closures). For + -- `--subject-only` (`buildVerifyConst`), the witness is a small + -- subject-only blob — keep Lean witness + `executeIxVM`. IO.println "── Phase 1: execute (witness generation) ──" + let ixePathBytes := ixePath.toUTF8 let mut execed : Array (Result × Address) := #[] for (label, addr) in targets do try - let witness ← mkWitness addr let (res, execSec) ← timed fun _ => - Aiur.Bytecode.Toplevel.execute compiled.bytecode funIdx - witness.input witness.inputIOBuffer + if subjectOnly then + let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr + compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + else + compiled.bytecode.checkAddrIxVM funIdx ixePathBytes addr.hash match res with | .error e => IO.eprintln s!" execute {label} failed: {e}" | .ok (_, _, queryCounts) => @@ -223,12 +231,19 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let mut ordered := execed.qsort (·.1.fftCost < ·.1.fftCost) writeJson (ordered.map (·.1)) let mut spent : Float := 0.0 + let ixePathBytes := ixePath.toUTF8 for i in [:ordered.size] do let (r, addr) := ordered[i]! try - let witness ← mkWitness addr - let (_, proveSec) ← timed fun _ => - aiurSystem.prove friParameters funIdx witness.input witness.inputIOBuffer + let (proveRes, proveSec) ← timed fun _ => + if subjectOnly then + let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr + .ok (aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer) + else + aiurSystem.proveAddrIxVM friParameters funIdx ixePathBytes addr.hash + match (proveRes : Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) with + | .error e => IO.eprintln s!" prove {r.name} failed: {e}"; continue + | .ok _ => pure () spent := spent + proveSec IO.println s!" {r.name}: prove={proveSec}s (cumulative {spent}s)" ordered := ordered.set! i ({ r with proveSec := some proveSec }, addr) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 1170b1d5..4a68a41e 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -96,6 +96,68 @@ def proveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ (claim, proof, ⟨ioData, ioMap⟩) +@[extern "rs_aiur_system_prove_addr_ixvm"] +private opaque proveAddrIxVM' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × Proof × + Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) + +/-- End-to-end per-claim prove: Rust builds the witness for + `Claim.check addr none` from the memory-mapped `.ixe` env at + `ixePath`, runs `execute_ixvm`, then drives the STARK prove + pipeline. Single FFI trip — the `IOBuffer` never crosses the + language boundary before prove time. Falls back to `proveIxVM` + on a Lean-built witness when the claim variant isn't + `check addr none`. -/ +def proveAddrIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (addrBytes : ByteArray) : + Except String (Array G × Proof × IOBuffer) := + match proveAddrIxVM' system friParameters funIdx ixePath addrBytes with + | .error e => .error e + | .ok (claim, proof, ioData, ioMap) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + .ok (claim, proof, ⟨ioData, ioMap⟩) + +@[extern "rs_aiur_system_prove_env_bytes_ixvm"] +private opaque proveEnvBytesIxVM' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × Proof × + Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) + +/-- Bytes-blob variant of `proveAddrIxVM`: the env is passed in as a + serialized blob (Lean's `Ixon.serEnv`) instead of a `.ixe` path. + Used by `ix prove NAME` without `--ixe`. -/ +def proveEnvBytesIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (envBytes : ByteArray) (addrBytes : ByteArray) : + Except String (Array G × Proof × IOBuffer) := + match proveEnvBytesIxVM' system friParameters funIdx envBytes addrBytes with + | .error e => .error e + | .ok (claim, proof, ioData, ioMap) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + .ok (claim, proof, ⟨ioData, ioMap⟩) + +@[extern "rs_aiur_system_shard_prove_ixvm"] +private opaque shardProveIxVM' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × Proof × + Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) + +/-- End-to-end per-shard prove. Rust builds the `CheckEnv` witness + over `ownedBlob` (flat 32-byte addresses), runs `execute_ixvm`, + and drives the STARK prove. Same return shape as + `proveAddrIxVM`. -/ +def shardProveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (ownedBlob : ByteArray) : + Except String (Array G × Proof × IOBuffer) := + match shardProveIxVM' system friParameters funIdx ixePath ownedBlob with + | .error e => .error e + | .ok (claim, proof, ioData, ioMap) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + .ok (claim, proof, ⟨ioData, ioMap⟩) + @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @& FriParameters → @& Array G → @& Proof → Except String Unit diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 3f3b191b..3265fd0f 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -133,6 +133,20 @@ private opaque shardCheckIxVM' : @& Bytecode.Toplevel → (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × Array (Nat × Nat)) +@[extern "rs_aiur_toplevel_check_addr_ixvm"] +private opaque checkAddrIxVM' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + +@[extern "rs_aiur_toplevel_check_env_bytes_ixvm"] +private opaque checkEnvBytesIxVM' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + /-- IxVM-native shard check: builds the witness in Rust (no per-byte boxing into Lean values), then dispatches through @@ -153,6 +167,37 @@ def shardCheckIxVM (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) +/-- IxVM-native per-claim fast path for `Claim.check addr none`. + Builds the witness in Rust (closure rooted at `addrBytes`), + dispatches through `execute_ixvm`. `ixePath` is a UTF-8 path to + a memory-mappable `.ixe` env; `addrBytes` is the 32-byte target + address. Same shape as `shardCheckIxVM`. -/ +def checkAddrIxVM (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (addrBytes : ByteArray) + : Except String (Array G × IOBuffer × Array QueryCount) := + match checkAddrIxVM' toplevel funIdx ixePath addrBytes with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + +/-- Bytes-blob variant of `checkAddrIxVM`: the env is passed in as a + serialized blob (Lean's `Ixon.serEnv`) instead of a `.ixe` path. + Used by the compiled-Lean-env code path (`ix check NAME` without + `--ixe`), where the env is built in Lean memory. -/ +def checkEnvBytesIxVM (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envBytes : ByteArray) (addrBytes : ByteArray) + : Except String (Array G × IOBuffer × Array QueryCount) := + match checkEnvBytesIxVM' toplevel funIdx envBytes addrBytes with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 871f2b38..f8564036 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -25,7 +25,7 @@ # Correctness invariant Generated code MUST produce a `QueryRecord` indistinguishable from - `src/aiur/execute.rs`'s interpreter: + `crates/aiur/src/execute.rs`'s interpreter: - `function_queries[idx].insert(args, output, mult)` MUST happen on `Ctrl::Return` of the callee, AFTER the callee's body's inserts. @@ -315,7 +315,7 @@ def calleeUnconstrained (opUn : Bool) : RustExpr := /-! ## Op emission - Each emitted Op mirrors `src/aiur/execute.rs`'s matching arm. The + Each emitted Op mirrors `crates/aiur/src/execute.rs`'s matching arm. The interpreter's `map: Vec` is gone: every Aiur ValIdx becomes a real Rust local `__v_{i}: G`. Per-op output counts decide how many new locals each op allocates; the counter is threaded via @@ -513,7 +513,7 @@ private def emitIOWrite (channel : ValIdx) (data : Array ValIdx) : Array RustStm -/ /-- Bytes1 op. No scratch Vec — the constrained branch calls - `bytes1_*_value` (defined in `crate::aiur::execute`) which + `bytes1_*_value` (defined in `aiur::execute`) which bumps the byte-chip queries and returns the gadget output by value; the unconstrained branch calls the pure `Bytes1::*` helper directly. -/ @@ -886,7 +886,7 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do def emitPreludeHeader : String := "// Auto-generated by Aiur codegen. Do not edit.\n\ //\n\ - // Mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly.\n\ + // Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly.\n\ //\n\ // Skip rustfmt — this file is huge and the codegen lays it out\n\ // for the compiler, not for humans.\n\ @@ -897,9 +897,9 @@ def emitPreludeHeader : String := )]\n\ \n\ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ - use crate::aiur::G;\n" + use aiur::G;\n" -/-- The set of optional `crate::aiur::execute` items the codegen +/-- The set of optional `aiur::execute` items the codegen might emit references to. Each pair is `(rust_path, search_token)` — if `search_token` appears anywhere in the body string, the item is included in the generated `use` block. The token is the exact @@ -924,7 +924,7 @@ def optionalExecuteUses : Array (String × String) := #[ ("CodegenBytes2 as Bytes2", "Bytes2::") ] -/-- Build the `use crate::aiur::execute::{...};` block, including only +/-- Build the `use aiur::execute::{...};` block, including only items whose search token appears in `body`. -/ def emitConditionalImports (body : String) : String := Id.run do let always : Array String := #["ExecError", "IOBuffer", "QueryRecord"] @@ -934,7 +934,7 @@ def emitConditionalImports (body : String) : String := Id.run do items := items.push path let joined : String := items.toList.foldl (fun acc s => if acc.isEmpty then s else acc ++ ", " ++ s) "" - s!"use crate::aiur::execute::\{ {joined} };\n\n" + s!"use aiur::execute::\{ {joined} };\n\n" /-- Build the dispatch entry point `pub fn execute_generated(...)` that maps a `fun_idx` to the right `aiur_fn_N` invocation. Mirrors diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 691445c8..9e934759 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -102,16 +102,40 @@ def emitStats (compiled : Aiur.CompiledToplevel) try Aiur.printStats stats finally let _ ← IO.setStdout old -/-- Run a single witness through the codegen'd IxVM Rust kernel - (`Bytecode.Toplevel.executeIxVM`). The bytecode interpreter is +/-- Source for a `verify_claim` invocation. + + * `native`: env is a `.ixe` file; Rust mmaps it and builds the + witness in Rust (parallel closure walk + parallel byte→G). + * `nativeBytes`: env is in-memory (compiled-Lean-env path); + Lean serializes to bytes via `Ixon.serEnv`, Rust decodes via + `Env::get` and runs the same witness builder. Avoids the + tmp-file round trip. + * `lean`: a pre-built `ClaimWitness` — used by `--claim ` + over a non-`check addr none` persisted claim, and by + `--interp` mode. -/ +inductive WitnessSource where + | native (ixePath : String) (addr : Address) + | nativeBytes (envBytes : ByteArray) (addr : Address) + | lean (witness : IxVM.ClaimHarness.ClaimWitness) + +/-- Run a single check claim through the codegen'd IxVM Rust kernel + (`executeIxVM` or `checkAddrIxVM`). The bytecode interpreter is no longer reachable from `ix check`. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (witness : IxVM.ClaimHarness.ClaimWitness) + (statsOut : Option String) (src : WitnessSource) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx witness.funcName |>.get! - match compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer with + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let res := + match src with + | .native ixePath addr => + compiled.bytecode.checkAddrIxVM funIdx ixePath.toUTF8 addr.hash + | .nativeBytes envBytes addr => + compiled.bytecode.checkEnvBytesIxVM funIdx envBytes addr.hash + | .lean witness => + compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + match res with | .error e => IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" return 1 @@ -140,16 +164,25 @@ def runInterp (decls : Aiur.Source.Decls) /-- Shared driver for `ix check` / `ix prove`. Loads either a `.ixe` env (with optional `--claim` over a persisted claim, or per-name iteration) or the compiled-in Lean env (per-name iteration only), - constructs each `(Claim, Witness, label)` triple, and dispatches - to `runOne`. Accumulates failures + prints a `[logTag]` summary. + constructs each `(Claim, WitnessSource, label)` triple, and + dispatches to `runOne`. Accumulates failures + prints a `[logTag]` + summary. `runOne` ignores `Claim` for `ix check` (the witness encodes the claim digest in its IO buffer); `ix prove` uses it to persist - the claim alongside the proof wrapper. -/ + the claim alongside the proof wrapper. + + The `WitnessSource` is `Native` (Rust-built witness from a + `.ixe` path + target addr) whenever both are available and the + claim is the common `Claim.check addr none` shape — avoids the + per-byte boxing into `Aiur.G` that dominates wall time on heavy + claims. Falls back to `Lean` when the env is the compiled-in + Lean env (no `.ixe` to mmap) or when the persisted `--claim` + variant isn't `check addr none`. -/ def forEachClaim (ixePath : Option String) (claimHex : Option String) (names : List String) (keepGoing : Bool) (logTag : String) - (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) + (runOne : Ix.Claim → WitnessSource → String → IO UInt32) : IO UInt32 := do let mut failures : Array String := #[] match ixePath with @@ -166,10 +199,18 @@ def forEachClaim {ixonEnv.constCount} consts, {ixonEnv.blobCount} blobs" if let some hex := claimHex then let (claim, trees) ← loadClaimAndTrees hex - let witness ← IO.ofExcept <| - IxVM.ClaimHarness.buildClaimWitness ixonEnv claim trees let label := s!"claim {hex}" - if (← runOne claim witness label) ≠ 0 then + -- Persisted `--claim` may be any `Claim` variant; only the + -- `check addr none` shape has a Rust-witness fast path today. + -- Other variants (eval/reveal/contains/checkEnv-with-asm) + -- still build the witness in Lean. + let src : WitnessSource ← match claim with + | .check addr none => pure (.native path addr) + | _ => + let witness ← IO.ofExcept <| + IxVM.ClaimHarness.buildClaimWitness ixonEnv claim trees + pure (.lean witness) + if (← runOne claim src label) ≠ 0 then failures := failures.push label else if names.isEmpty then let sorted := ixonEnv.named.toArray.qsort @@ -178,8 +219,7 @@ def forEachClaim let leanName := ixNameToLeanName ixName let label := toString leanName let claim := Ix.Claim.check named.addr none - let witness ← mkWitness named.addr ixonEnv - if (← runOne claim witness label) ≠ 0 then + if (← runOne claim (.native path named.addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -192,28 +232,31 @@ def forEachClaim | some addr => let label := arg let claim := Ix.Claim.check addr none - let witness ← mkWitness addr ixonEnv - if (← runOne claim witness label) ≠ 0 then + if (← runOne claim (.native path addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break | none => if claimHex.isSome then IO.eprintln "error: --claim requires --ixe "; return 1 let env ← get_env! + -- Compiled-Lean-env path. Builds the Ixon env per-name in + -- Lean memory, serializes to a byte blob, and hands off to + -- the Rust witness builder via `nativeBytes`. Same fast path + -- as the `--ixe` route — only the env-source differs. let buildOne (name : Lean.Name) : - IO (Ix.Claim × IxVM.ClaimHarness.ClaimWitness) := do + IO (Ix.Claim × ByteArray × Address) := do let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv name env let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name let claim := Ix.Claim.check addr none - let witness ← mkWitness addr ixonEnv - pure (claim, witness) + let envBytes := Ixon.serEnv ixonEnv + pure (claim, envBytes, addr) if names.isEmpty then let sorted := env.constants.toList.toArray.qsort (fun a b => toString a.1 < toString b.1) for (name, _) in sorted do let label := toString name - let (claim, witness) ← buildOne name - if (← runOne claim witness label) ≠ 0 then + let (claim, envBytes, addr) ← buildOne name + if (← runOne claim (.nativeBytes envBytes addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -226,8 +269,8 @@ def forEachClaim else continue | some name => let label := toString name - let (claim, witness) ← buildOne name - if (← runOne claim witness label) ≠ 0 then + let (claim, envBytes, addr) ← buildOne name + if (← runOne claim (.nativeBytes envBytes addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break @@ -504,17 +547,43 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 | .ok t => pure t - let runOne : IxVM.ClaimHarness.ClaimWitness → String → IO UInt32 ← + -- The per-claim `runOne` accepts a `WitnessSource` (Rust-native + -- via `--ixe`, or Lean-built for the compiled-Lean-env path). + -- The legacy `--interp` route needs a fully-built `ClaimWitness` + -- in Lean, so it materialises the witness from the source first + -- (the `--interp` path is expected to be small constants for + -- developer ergonomics — heavy claims are run in production via + -- the codegen path). + let materialise (src : WitnessSource) : IO IxVM.ClaimHarness.ClaimWitness := + match src with + | .lean w => pure w + | .native ixe addr => do + let bytes ← IO.FS.readBinFile ixe + let ixonEnv ← match Ixon.deEnvAnon bytes with + | .error e => throw (IO.userError s!"deserialize {ixe} failed: {e}") + | .ok env => pure env + mkWitness addr ixonEnv + | .nativeBytes envBytes addr => do + let ixonEnv ← match Ixon.deEnv envBytes with + | .error e => throw (IO.userError s!"deserialize env bytes failed: {e}") + | .ok env => pure env + mkWitness addr ixonEnv + let runOne : Ix.Claim → WitnessSource → String → IO UInt32 ← if interp then do let decls ← match toplevel.mkDecls with | .error e => IO.eprintln s!"mkDecls failed: {e}"; return 1 | .ok d => pure d - pure (runInterp decls) + let go (_ : Ix.Claim) (src : WitnessSource) (label : String) : IO UInt32 := do + let witness ← materialise src + runInterp decls witness label + pure go else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - pure (runCompiled compiled printStats statsOut) + let go (_ : Ix.Claim) (src : WitnessSource) (label : String) : IO UInt32 := + runCompiled compiled printStats statsOut src label + pure go match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => -- IxVM-native shard check: witness built in Rust (Lean's @@ -523,7 +592,8 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do -- Falls back to the legacy path when `--interp` is set, since -- the Lean interpreter consumes a `ClaimWitness` directly. if interp then - return (← runShardCheckManifest manifest ixe k (fun _c w l => runOne w l)) + return (← runShardCheckManifest manifest ixe k + (fun c w l => runOne c (.lean w) l)) else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 @@ -532,7 +602,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | some ixe, some manifest, none => if interp then return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) - (fun _c w l => runOne w l)) + (fun c w l => runOne c (.lean w) l)) else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 @@ -540,8 +610,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do return (← runShardManifestAllNative manifest ixe ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut) | _, _, _ => - forEachClaim ixePath claimHex names keepGoing "check" - (fun _ w l => runOne w l) + forEachClaim ixePath claimHex names keepGoing "check" runOne end Ix.Cli.CheckCmd diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index 51e40b43..4fbdef59 100644 --- a/Ix/Cli/CodegenCmd.lean +++ b/Ix/Cli/CodegenCmd.lean @@ -2,8 +2,8 @@ `ix codegen`: write the IxVM kernel as a Rust source file via the Bytecode → Rust codegen pass. - Output path is fixed at compile time: `src/ix/aiur_ixvm.rs`. The - generated file is the single destination; no flag overrides. + Output path is fixed at compile time: `crates/ix/src/aiur_ixvm.rs`. + The generated file is the single destination; no flag overrides. Output: a Rust module body containing one `fn aiur_fn_N(...)` per Aiur kernel function, plus per-fn `IN_N` / `OUT_N` / `INPUT_SIZE_N` @@ -33,7 +33,7 @@ namespace Ix.Cli.CodegenCmd open Aiur /-- Fixed destination — compile-time constant, no CLI override. -/ -def codegenOutPath : String := "src/ix/aiur_ixvm.rs" +def codegenOutPath : String := "crates/ix/src/aiur_ixvm.rs" def runCodegenCmd (_p : Cli.Parsed) : IO UInt32 := do -- Compile the IxVM source to bytecode. @@ -54,7 +54,7 @@ end Ix.Cli.CodegenCmd open Ix.Cli.CodegenCmd in def codegenCmd : Cli.Cmd := `[Cli| "codegen" VIA runCodegenCmd; - "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `src/ix/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces." + "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ix/src/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces." ] end diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 135edb48..e0160036 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -58,32 +58,90 @@ private def friParameters : Aiur.FriParameters := { queryProofOfWorkBits := 0 } -/-- Run Aiur prove for one (claim, witness) pair, wrap into an - `Ixon.Proof`, persist claim + wrapper, and print the resulting - proof hex. Plugs into `Ix.Cli.CheckCmd.forEachClaim`. -/ def proveOne (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) (claim : Ix.Claim) - (witness : IxVM.ClaimHarness.ClaimWitness) + (src : Ix.Cli.CheckCmd.WitnessSource) (label : String) : IO UInt32 := do IO.println s!"Proving {label}" (← IO.getStdout).flush - let funIdx ← match compiled.getFuncIdx witness.funcName with + let funIdx ← match compiled.getFuncIdx `verify_claim with | some i => pure i | none => - IO.eprintln s!"{label}: entrypoint `{witness.funcName}` missing from compiled toplevel" + IO.eprintln s!"{label}: entrypoint `verify_claim` missing from compiled toplevel" return 1 let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) -- Native IxVM path: routes execution through the codegen'd Rust - -- kernel (`execute_generated`) instead of the bytecode interpreter. - -- Proof verification-compatible with the interpreter path. - let (_aiurClaim, proof, _outIO) := - aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer + -- kernel (`execute_generated`). For `Claim.check addr none` via + -- `--ixe`, witness + execute + STARK prove run end-to-end in + -- Rust (`proveAddrIxVM`) — no Lean-side per-byte boxing into + -- `Aiur.G`. The Lean fallback path consumes a pre-built + -- `ClaimWitness` (compiled-Lean-env, or a non-`check` persisted + -- claim). + let proof : Aiur.Proof ← match src with + | .native ixe addr => + match aiurSystem.proveAddrIxVM friParameters funIdx + ixe.toUTF8 addr.hash with + | .error e => + IO.eprintln s!"{label}: proveAddrIxVM error: {e}" + return 1 + | .ok (_aiurClaim, proof, _outIO) => pure proof + | .nativeBytes envBytes addr => + match aiurSystem.proveEnvBytesIxVM friParameters funIdx envBytes addr.hash with + | .error e => + IO.eprintln s!"{label}: proveEnvBytesIxVM error: {e}" + return 1 + | .ok (_aiurClaim, proof, _outIO) => pure proof + | .lean witness => + let (_aiurClaim, proof, _outIO) := + aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer + pure proof let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) return 0 +/-- Per-shard prove via the end-to-end Rust path + (`shardProveIxVM`): witness build, `execute_ixvm`, and STARK + prove run in one FFI trip with the parallel Rust witness + builder. -/ +def runShardProveNative (manifestPath ixePath : String) (shardK : Nat) + (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (printStats : Bool) : IO UInt32 := do + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + match shards[shardK]? with + | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 + | some blocks => do + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + let label := s!"shard {shardK}" + IO.println s!"Proving {label}" + (← IO.getStdout).flush + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + match aiurSystem.shardProveIxVM friParameters funIdx + ixePath.toUTF8 blob with + | .error e => + IO.eprintln s!"{label}: shardProveIxVM error: {e}" + return 1 + | .ok (_aiurClaim, proof, _outIO) => + -- Reconstruct the shard's CheckEnv claim from the owned + -- blocks so we can persist (claim, proof) like proveOne. + match IxVM.ClaimHarness.shardCheckEnvClaim ixonEnv owned with + | .error e => + IO.eprintln s!"{label}: claim reconstruct failed: {e}" + return 1 + | .ok (claim, _closure, _trees) => do + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } + let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + IO.println (toString proofAddr) + if printStats then pure () -- TODO: surface query-counts if needed + return 0 + def runProveCmd (p : Cli.Parsed) : IO UInt32 := do Std.Internal.UV.System.osSetenv "IX_QUIET" "1" let keepGoing := p.hasFlag "keep-going" @@ -100,9 +158,18 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let runOne := proveOne aiurSystem compiled match ixePath, (p.flag? "ixes").map (·.as! String), (p.flag? "shard").map (·.as! Nat) with | some ixe, some manifest, some k => - Ix.Cli.CheckCmd.runShardCheckManifest manifest ixe k runOne + -- IxVM-native shard prove: witness + execute + STARK prove all + -- in Rust via `shardProveIxVM`. + runShardProveNative manifest ixe k aiurSystem compiled false | some ixe, some manifest, none => - Ix.Cli.CheckCmd.runShardManifestAll manifest ixe runOne + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with + | .error e => IO.eprintln e; return 1 + | .ok (_, shards) => + let mut rc : UInt32 := 0 + for k in [0 : shards.size] do + if (← runShardProveNative manifest ixe k aiurSystem compiled false) != 0 then + rc := 1 + pure rc | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" runOne diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 99a5080f..98a19507 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -370,6 +370,203 @@ extern "C" fn rs_aiur_toplevel_shard_check_ixvm( LeanExcept::ok(result) } +/// `Bytecode.Toplevel.checkAddrIxVM`: per-claim fast path for the +/// common `Claim.check addr none` variant. Builds the witness in +/// Rust from a memory-mapped `.ixe` env (closure rooted at `addr`), +/// then dispatches to `execute_ixvm`. Same `(output, ioBuffer, +/// queryCounts)` return shape as `rs_aiur_toplevel_shard_check_ixvm` +/// so the Lean shim is drop-in. +/// +/// Only handles `Claim.check addr none` — the asm-tree-bearing +/// variants of `Claim` still go through Lean witness for now (rare +/// path: only `ix check --claim ` loaded from store). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_check_addr_ixvm( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + ixe_path: LeanByteArray>, + addr_bytes: LeanByteArray>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let ixe_path_str = + String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); + + let addr_slice = addr_bytes.as_bytes(); + if addr_slice.len() != 32 { + return LeanExcept::error_string(&format!( + "addr_bytes: expected 32-byte address, got {} bytes", + addr_slice.len() + )); + } + let addr = ix_common::address::Address::from_slice(addr_slice) + .expect("32-byte slice already length-checked"); + + let env = match ixon::Env::get_anon_mmap( + std::path::Path::new(&ixe_path_str), + ) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + }; + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, + fun_idx, + input, + &mut io_buffer, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), + }; + + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let lean_query_counts = { + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr + }; + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + +/// `Bytecode.Toplevel.checkAddrBytesIxVM`: same as +/// `rs_aiur_toplevel_check_addr_ixvm` but takes the env as a +/// serialized byte blob instead of a `.ixe` path. Used by the +/// compiled-Lean-env code path (`ix check NAME` without `--ixe`), +/// where the env is built in Lean memory and never written to disk. +/// Lean serializes with `Ixon.serEnv`; Rust decodes with `Env::get`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_check_env_bytes_ixvm( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + env_bytes: LeanByteArray>, + addr_bytes: LeanByteArray>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + + let addr_slice = addr_bytes.as_bytes(); + if addr_slice.len() != 32 { + return LeanExcept::error_string(&format!( + "addr_bytes: expected 32-byte address, got {} bytes", + addr_slice.len() + )); + } + let addr = ix_common::address::Address::from_slice(addr_slice) + .expect("32-byte slice already length-checked"); + + let mut cursor: &[u8] = env_bytes.as_bytes(); + let mut env = match ixon::Env::get(&mut cursor) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env decode: {e}")), + }; + // `Env::get` doesn't harvest `anon_hints` from the named entries + // (only `get_anon` does). The kernel's `verify_claim` reads ch 3 + // (Defn reducibility hints) — populate it here so the witness + // includes hint entries for every `Defn` named entry. + let hints_to_insert: Vec<(ix_common::address::Address, ix_common::env::ReducibilityHints)> = + env.named.iter() + .filter_map(|entry| { + let named = entry.value(); + match &named.meta.info { + ixon::metadata::ConstantMetaInfo::Def { hints, .. } => + Some((named.addr.clone(), hints.clone())), + _ => None, + } + }) + .collect(); + for (addr, hints) in hints_to_insert { + env.anon_hints.insert(addr, hints); + } + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, + fun_idx, + input, + &mut io_buffer, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), + }; + + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let lean_query_counts = { + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr + }; + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + /// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape /// as `rs_aiur_system_prove`, but routes execution through the /// codegen'd Rust kernel (`execute_generated`) via @@ -405,6 +602,198 @@ extern "C" fn rs_aiur_system_prove_ixvm( result.into() } +/// `AiurSystem.proveAddrIxVM`: end-to-end per-claim fast path — +/// builds the witness for `Claim.check addr none` in Rust, runs +/// `execute_ixvm`, then drives the STARK prove pipeline. Single +/// FFI trip; the `IOBuffer` never crosses the language boundary +/// before prove time. +/// +/// Returns `(claim_array, (proof, output_ioBuffer))` matching the +/// shape of `rs_aiur_system_prove_ixvm` so the Lean wrapper stays +/// drop-in. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_prove_addr_ixvm( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + ixe_path: LeanByteArray>, + addr_bytes: LeanByteArray>, +) -> LeanExcept { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let ixe_path_str = + String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); + + let addr_slice = addr_bytes.as_bytes(); + if addr_slice.len() != 32 { + return LeanExcept::error_string(&format!( + "addr_bytes: expected 32-byte address, got {} bytes", + addr_slice.len() + )); + } + let addr = ix_common::address::Address::from_slice(addr_slice) + .expect("32-byte slice already length-checked"); + + let env = match ixon::Env::get_anon_mmap( + std::path::Path::new(&ixe_path_str), + ) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + }; + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (claim, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &input, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io_tuple = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + LeanExcept::ok(result) +} + +/// `AiurSystem.proveEnvBytesIxVM`: bytes-blob counterpart to +/// `rs_aiur_system_prove_addr_ixvm`. Used by `ix prove NAME` +/// without `--ixe` (compiled-Lean-env path). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_prove_env_bytes_ixvm( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + env_bytes: LeanByteArray>, + addr_bytes: LeanByteArray>, +) -> LeanExcept { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + + let addr_slice = addr_bytes.as_bytes(); + if addr_slice.len() != 32 { + return LeanExcept::error_string(&format!( + "addr_bytes: expected 32-byte address, got {} bytes", + addr_slice.len() + )); + } + let addr = ix_common::address::Address::from_slice(addr_slice) + .expect("32-byte slice already length-checked"); + + let mut cursor: &[u8] = env_bytes.as_bytes(); + let mut env = match ixon::Env::get(&mut cursor) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env decode: {e}")), + }; + // `Env::get` doesn't harvest `anon_hints` from the named entries + // (only `get_anon` does). The kernel's `verify_claim` reads ch 3 + // (Defn reducibility hints) — populate it here so the witness + // includes hint entries for every `Defn` named entry. + let hints_to_insert: Vec<(ix_common::address::Address, ix_common::env::ReducibilityHints)> = + env.named.iter() + .filter_map(|entry| { + let named = entry.value(); + match &named.meta.info { + ixon::metadata::ConstantMetaInfo::Def { hints, .. } => + Some((named.addr.clone(), hints.clone())), + _ => None, + } + }) + .collect(); + for (addr, hints) in hints_to_insert { + env.anon_hints.insert(addr, hints); + } + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (claim, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &input, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io_tuple = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + LeanExcept::ok(result) +} + +/// `AiurSystem.shardProveIxVM`: end-to-end per-shard fast path. +/// Same as `rs_aiur_system_prove_addr_ixvm` but the witness is a +/// `CheckEnv` over `owned_blob` (the shard's owned consts), built +/// via `build_shard_check_env_witness` (parallel closure walk + +/// per-byte conversion). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_shard_prove_ixvm( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + ixe_path: LeanByteArray>, + owned_blob: LeanByteArray>, +) -> LeanExcept { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let ixe_path_str = + String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); + + let bytes = owned_blob.as_bytes(); + if bytes.len() % 32 != 0 { + return LeanExcept::error_string(&format!( + "owned_blob: length {} not a multiple of 32", + bytes.len() + )); + } + let owned: Vec = bytes + .chunks_exact(32) + .map(|c| ix_common::address::Address::from_slice(c).unwrap()) + .collect(); + + let env = match ixon::Env::get_anon_mmap( + std::path::Path::new(&ixe_path_str), + ) { + Ok(e) => e, + Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + }; + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_shard_check_env_witness( + &env, &owned, + ) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (claim, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &input, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io_tuple = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + LeanExcept::ok(result) +} + // ============================================================================= // Helpers // ============================================================================= diff --git a/crates/ix/src/aiur_ixvm.rs b/crates/ix/src/aiur_ixvm.rs index ba0ce71b..61040c96 100644 --- a/crates/ix/src/aiur_ixvm.rs +++ b/crates/ix/src/aiur_ixvm.rs @@ -1,6 +1,6 @@ // Auto-generated by Aiur codegen. Do not edit. // -// Mirrors `src/aiur/execute.rs`'s QueryRecord side effects exactly. +// Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly. // // Skip rustfmt — this file is huge and the codegen lays it out // for the compiler, not for humans. diff --git a/crates/ix/src/aiur_ixvm_witness.rs b/crates/ix/src/aiur_ixvm_witness.rs index 607f69ab..59d8c04e 100644 --- a/crates/ix/src/aiur_ixvm_witness.rs +++ b/crates/ix/src/aiur_ixvm_witness.rs @@ -216,6 +216,42 @@ fn add_entries_parallel( } } +/// Build a `Check { const_addr, assumptions=None }` claim witness +/// directly in Rust. Returns `(claim, claim_digest_input, io_buffer)` +/// ready to feed to `crate::ix::aiur_ixvm_runner::execute_ixvm`. +/// +/// Mirrors `IxVM.ClaimHarness.buildClaimWitness` on the +/// `Claim.check addr none` branch: closure-from-addr seeds ch 2/3/4/5, +/// claim bytes go to ch 0. Asm-tree variant deferred — caller falls +/// back to Lean witness when `asm = Some _`. +pub fn build_claim_check_witness( + env: &Env, + target: &Address, +) -> Result<(Claim, Vec, IOBuffer), String> { + // Transitive closure rooted at `target`. + let closure: FxHashSet
= closure_from_set(env, &[target.clone()]); + + let claim = Claim::Check { + const_addr: target.clone(), + assumptions: None, + }; + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let digest_key = addr_key(&digest); + + let mut io = IOBuffer { + data: rustc_hash::FxHashMap::default(), + map: rustc_hash::FxHashMap::default(), + }; + // ch 0: claim bytes + extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); + // ch 2/3/4/5: per-const/blob/hint entries — parallel byte conversion. + add_entries_parallel(env, &closure, &mut io); + + Ok((claim, digest_key, io)) +} + /// Build a `CheckEnv`-shaped shard witness directly in Rust. Returns /// `(claim, claim_digest_input, io_buffer)` ready to feed to /// `crate::ix::aiur_ixvm_runner::execute_ixvm`. From 38a6253cfae8182ca9dd0139d6a4581b77a596d2 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 14:29:42 -0700 Subject: [PATCH 09/11] EnvHandle: Rust-owned env shared across per-claim / per-shard FFI calls MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Before: every per-claim and per-shard FFI re-parsed the Ixon env (`Env::get_anon_mmap` per call). On `--ixe + many names` / all-shards prove, this is the dominant overhead for iteration-heavy workflows — O(num_consts) lazy-index build × N targets. After: the env lives once per CLI invocation in a Rust-owned `EnvHandle`. Lean holds an opaque `Aiur.EnvHandle` reference and threads `@& EnvHandle` through every per-target FFI call. The env is parsed exactly once at handle construction; downstream calls share it. # Surface Five new FFIs collapse the previous six per-call variants (`checkAddrIxVM`, `checkEnvBytesIxVM`, `shardCheckIxVM`, `proveAddrIxVM`, `proveEnvBytesIxVM`, `shardProveIxVM` — all deleted): * `rs_aiur_env_handle_from_ixe(path) → LeanExternal`: mmap-load via `Env::get_anon_mmap`. Anon parser already harvests `anon_hints`; no post-pass. * `rs_aiur_env_handle_from_bytes(blob) → LeanExternal`: decode `Ixon.serEnv`-shape blob via `Env::get` + harvest `anon_hints` from each `Def` named entry. Used by the compiled-Lean-env path. * `rs_aiur_toplevel_check_addr_with_env(toplevel, fun_idx, handle, addr_bytes)`: per-claim check. Reuses handle's parsed env. * `rs_aiur_toplevel_shard_check_with_env(toplevel, fun_idx, handle, owned_blob)`: per-shard check. * `rs_aiur_system_prove_addr_with_env(system, fri, fun_idx, handle, addr_bytes) → (claim_bytes, proof, ioBuffer)`: per-claim prove. Rust serializes the reconstructed `Ix.Claim` via `ixon::Claim::put` so Lean can deserialize via `Ixon.runGet Ix.Claim.get` directly — no closure walk + canonical `AssumptionTree` recomputation Lean-side. * `rs_aiur_system_shard_prove_with_env(system, fri, fun_idx, handle, owned_blob) → (claim_bytes, proof, ioBuffer)`: per-shard prove. # Lean * `Aiur.EnvHandle` opaque type with `fromIxe` / `fromBytes`. * `Aiur.Bytecode.Toplevel.checkAddrWithEnv` / `shardCheckWithEnv`, `Aiur.AiurSystem.proveAddrWithEnv` / `shardProveWithEnv`. * `Ix.Cli.CheckCmd.Target` replaces `WitnessSource`: ```lean inductive Target where | addr (a : Address) -- Claim.check addr none | shard (owned : Array Address) -- Claim.checkEnv | leanW (w : ClaimWitness) -- --interp, --claim non-check ``` `runCompiled` / `proveOne` take `(envHandle?, target)`. The envHandle is `none` only for `.leanW` (`--interp` legacy path). * `runShardOwnedNative` and the manifest-driver helpers take the envHandle as a parameter. Single-shard mode builds it once; all-shards mode reuses the same handle across every shard's FFI call (eliminates per-shard re-mmap). * `runShardProveNative` deserializes the wire claim bytes via `Ixon.runGet Ix.Claim.get` instead of re-running `shardCheckEnvClaim`. # Benchmarks `Benchmarks/Typecheck.lean` builds the envHandle once before Phase 1, reuses it across Phase 1 (execute) + Phase 2 (prove). Both phases now go through `checkAddrWithEnv` / `proveAddrWithEnv` on the full-closure path. `--subject-only` still uses Lean `buildVerifyConst` + `executeIxVM` / `proveIxVM` (witnesses intentionally small there). # New crate `crates/ix/src/env_handle.rs` — the `EnvHandle` struct + constructors live in the existing `ix` crate next to the witness builder and codegen runner. # Sanity * Multi-target check (warm): `ix check --ixe init.ixe Nat.add_comm Nat.add` → 3.3 s wall, single envHandle shared across both targets. * Shard 26 check (warm): `ix check --ixe init.ixe --ixes init.ixes --shard 26` → ~78 s wall, FFT = 107_006_963_281 (parity preserved). # Coverage | Command | Path | |--------------------------------------|-----------------------------------| | `ix check NAME --ixe` | `checkAddrWithEnv` | | `ix check NAME` (no `--ixe`) | `checkAddrWithEnv` + fromBytes | | `ix check --claim hex --ixe` | `checkAddrWithEnv` for check-none | | `ix check --ixes --shard K` | `shardCheckWithEnv` | | `ix check --ixes` | `shardCheckWithEnv` × all shards | | `ix prove NAME --ixe` | `proveAddrWithEnv` | | `ix prove --ixes --shard K` | `shardProveWithEnv` | | `ix prove --ixes` | `shardProveWithEnv` × all shards | | `Benchmarks/Typecheck` Phase 1+2 | `checkAddrWithEnv` / `proveAddrWithEnv` | Only `--interp` and `--claim hex` over a non-`check addr none` persisted claim still build a Lean `ClaimWitness`; both go via the `.leanW` target arm. --- Benchmarks/Typecheck.lean | 40 +- Ix/Aiur/Protocol.lean | 75 ++-- Ix/Aiur/Semantics/BytecodeFfi.lean | 96 ++--- Ix/Cli/CheckCmd.lean | 209 ++++++----- Ix/Cli/ProveCmd.lean | 127 ++++--- crates/ffi/src/aiur/protocol.rs | 566 ++++++++++------------------- crates/ix/src/env_handle.rs | 59 +++ crates/ix/src/lib.rs | 1 + 8 files changed, 525 insertions(+), 648 deletions(-) create mode 100644 crates/ix/src/env_handle.rs diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 7bd9cc02..047cbec7 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -172,11 +172,6 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1 | .ok env => pure env IO.println s!"Loaded {ixePath}: {ixonEnv.namedCount} named, {ixonEnv.constCount} consts" - -- Build the witness for `addr`: subject-only (`verify_const`) trusts deps; - -- otherwise the full-closure check (`verify_claim`, `check addr none`). - let mkWitness (addr : Address) : IO IxVM.ClaimHarness.ClaimWitness := - if subjectOnly then pure (IxVM.ClaimHarness.buildVerifyConst ixonEnv addr) - else IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness ixonEnv (Ix.Claim.check addr none)) let mut targets : Array (String × Address) := #[] for arg in nameArgs do match Ix.Cli.NameResolve.resolveIxeAddr ixonEnv arg with @@ -186,15 +181,19 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln "no requested constants were found in the env" return 1 + -- Build the env once into a Rust-owned `EnvHandle` and share it + -- across both Phase 1 and Phase 2 loops. Per-target FFI calls + -- reuse the parsed env — no per-call mmap / lazy-index rebuild. + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + -- Phase 1: execute every constant (cheap, deterministic structural metrics). - -- Carry each target's address through so phase 2 can rebuild its witness. - -- For full-closure check claims (`Claim.check addr none`), use the - -- Rust-native fast path `checkAddrIxVM`: skips per-byte boxing into - -- `Aiur.G` (the dominant cost on heavy closures). For - -- `--subject-only` (`buildVerifyConst`), the witness is a small - -- subject-only blob — keep Lean witness + `executeIxVM`. + -- For full-closure check claims, use `checkAddrWithEnv` against the + -- shared `envHandle`. For `--subject-only` (`buildVerifyConst`), the + -- witness is a small subject-only blob — keep Lean witness + + -- `executeIxVM`. IO.println "── Phase 1: execute (witness generation) ──" - let ixePathBytes := ixePath.toUTF8 let mut execed : Array (Result × Address) := #[] for (label, addr) in targets do try @@ -203,7 +202,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer else - compiled.bytecode.checkAddrIxVM funIdx ixePathBytes addr.hash + compiled.bytecode.checkAddrWithEnv funIdx envHandle addr.hash match res with | .error e => IO.eprintln s!" execute {label} failed: {e}" | .ok (_, _, queryCounts) => @@ -231,16 +230,25 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let mut ordered := execed.qsort (·.1.fftCost < ·.1.fftCost) writeJson (ordered.map (·.1)) let mut spent : Float := 0.0 - let ixePathBytes := ixePath.toUTF8 for i in [:ordered.size] do let (r, addr) := ordered[i]! try let (proveRes, proveSec) ← timed fun _ => if subjectOnly then let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr - .ok (aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer) + let (claim, proof, ioBuf) := + aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer + (.ok (claim, proof, ioBuf) : + Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) else - aiurSystem.proveAddrIxVM friParameters funIdx ixePathBytes addr.hash + match aiurSystem.proveAddrWithEnv friParameters funIdx envHandle addr.hash with + | .error e => .error e + | .ok (_claimBytes, proof, ioBuf) => + -- The shared envHandle path doesn't return an `Array G` + -- claim — adapt to the existing benchmark return shape + -- by recomputing the claim digest from the witness's + -- input (Phase 2 doesn't read it). + .ok (#[], proof, ioBuf) match (proveRes : Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) with | .error e => IO.eprintln s!" prove {r.name} failed: {e}"; continue | .ok _ => pure () diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 4a68a41e..b5d6b332 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -96,67 +96,42 @@ def proveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ (claim, proof, ⟨ioData, ioMap⟩) -@[extern "rs_aiur_system_prove_addr_ixvm"] -private opaque proveAddrIxVM' : @& AiurSystem → @& FriParameters → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → - Except String (Array G × Proof × +@[extern "rs_aiur_system_prove_addr_with_env"] +private opaque proveAddrWithEnv' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + Except String (ByteArray × Proof × Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) -/-- End-to-end per-claim prove: Rust builds the witness for - `Claim.check addr none` from the memory-mapped `.ixe` env at - `ixePath`, runs `execute_ixvm`, then drives the STARK prove - pipeline. Single FFI trip — the `IOBuffer` never crosses the - language boundary before prove time. Falls back to `proveIxVM` - on a Lean-built witness when the claim variant isn't - `check addr none`. -/ -def proveAddrIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) - (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (addrBytes : ByteArray) : - Except String (Array G × Proof × IOBuffer) := - match proveAddrIxVM' system friParameters funIdx ixePath addrBytes with +/-- Per-claim prove against a Rust-owned `EnvHandle`. Returns + `(claimBytes, proof, ioBuffer)` — Rust serializes the + reconstructed `Ix.Claim` via `ixon::Claim::put` so Lean can + deserialize directly without re-running the closure walk. -/ +def proveAddrWithEnv (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) : + Except String (ByteArray × Proof × IOBuffer) := + match proveAddrWithEnv' system friParameters funIdx envHandle addrBytes with | .error e => .error e - | .ok (claim, proof, ioData, ioMap) => + | .ok (claimBytes, proof, ioData, ioMap) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ - .ok (claim, proof, ⟨ioData, ioMap⟩) + .ok (claimBytes, proof, ⟨ioData, ioMap⟩) -@[extern "rs_aiur_system_prove_env_bytes_ixvm"] -private opaque proveEnvBytesIxVM' : @& AiurSystem → @& FriParameters → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → - Except String (Array G × Proof × +@[extern "rs_aiur_system_shard_prove_with_env"] +private opaque shardProveWithEnv' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + Except String (ByteArray × Proof × Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) -/-- Bytes-blob variant of `proveAddrIxVM`: the env is passed in as a - serialized blob (Lean's `Ixon.serEnv`) instead of a `.ixe` path. - Used by `ix prove NAME` without `--ixe`. -/ -def proveEnvBytesIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) - (funIdx : @& Bytecode.FunIdx) (envBytes : ByteArray) (addrBytes : ByteArray) : - Except String (Array G × Proof × IOBuffer) := - match proveEnvBytesIxVM' system friParameters funIdx envBytes addrBytes with +/-- Per-shard prove against a Rust-owned `EnvHandle`. -/ +def shardProveWithEnv (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) : + Except String (ByteArray × Proof × IOBuffer) := + match shardProveWithEnv' system friParameters funIdx envHandle ownedBlob with | .error e => .error e - | .ok (claim, proof, ioData, ioMap) => + | .ok (claimBytes, proof, ioData, ioMap) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ - .ok (claim, proof, ⟨ioData, ioMap⟩) - -@[extern "rs_aiur_system_shard_prove_ixvm"] -private opaque shardProveIxVM' : @& AiurSystem → @& FriParameters → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → - Except String (Array G × Proof × - Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) - -/-- End-to-end per-shard prove. Rust builds the `CheckEnv` witness - over `ownedBlob` (flat 32-byte addresses), runs `execute_ixvm`, - and drives the STARK prove. Same return shape as - `proveAddrIxVM`. -/ -def shardProveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) - (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (ownedBlob : ByteArray) : - Except String (Array G × Proof × IOBuffer) := - match shardProveIxVM' system friParameters funIdx ixePath ownedBlob with - | .error e => .error e - | .ok (claim, proof, ioData, ioMap) => - let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ - let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ - .ok (claim, proof, ⟨ioData, ioMap⟩) + .ok (claimBytes, proof, ⟨ioData, ioMap⟩) @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @& FriParameters → diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 3265fd0f..b2362c8f 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -67,6 +67,37 @@ structure QueryCount where totalHits : Nat deriving Inhabited +-- =========================================================================== +-- EnvHandle: Rust-owned `ixon::Env` exposed to Lean as an opaque handle. +-- Built once per CLI invocation; reused across every per-claim and +-- per-shard FFI call so the env is parsed exactly once. +-- =========================================================================== + +private opaque EnvHandleNonempty : NonemptyType +def EnvHandle : Type := EnvHandleNonempty.type +instance : Nonempty EnvHandle := EnvHandleNonempty.property + +namespace EnvHandle + +@[extern "rs_aiur_env_handle_from_ixe"] +private opaque fromIxe' : @& ByteArray → Except String EnvHandle + +/-- Load an `EnvHandle` from a `.ixe` file path (UTF-8 ByteArray). + Rust mmap's the file zero-copy; the handle keeps the mapping + alive for as long as Lean retains it. -/ +def fromIxe (path : String) : Except String EnvHandle := + fromIxe' path.toUTF8 + +@[extern "rs_aiur_env_handle_from_bytes"] +private opaque fromBytes' : @& ByteArray → Except String EnvHandle + +/-- Build an `EnvHandle` from a serialized env blob (e.g. produced + by `Ixon.serEnv` on the compiled-Lean-env code path). -/ +def fromBytes (bytes : ByteArray) : Except String EnvHandle := + fromBytes' bytes + +end EnvHandle + namespace Bytecode.Toplevel @[extern "rs_aiur_toplevel_execute"] @@ -126,56 +157,32 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) -@[extern "rs_aiur_toplevel_shard_check_ixvm"] -private opaque shardCheckIxVM' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → - Except String (Array G × - (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × - Array (Nat × Nat)) +-- (EnvHandle opaque type + constructors live above `namespace +-- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI +-- declarations below reference `EnvHandle` and `Bytecode.Toplevel` +-- from the same scope.) -@[extern "rs_aiur_toplevel_check_addr_ixvm"] -private opaque checkAddrIxVM' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → +@[extern "rs_aiur_toplevel_check_addr_with_env"] +private opaque checkAddrWithEnv' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Except String (Array G × (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × Array (Nat × Nat)) -@[extern "rs_aiur_toplevel_check_env_bytes_ixvm"] -private opaque checkEnvBytesIxVM' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& ByteArray → @& ByteArray → +@[extern "rs_aiur_toplevel_shard_check_with_env"] +private opaque shardCheckWithEnv' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Except String (Array G × (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × Array (Nat × Nat)) -/-- IxVM-native shard check: builds the witness in Rust (no - per-byte boxing into Lean values), then dispatches through - `execute_ixvm`. Replaces `buildShardCheckEnvWitness` + `executeIxVM` - with a single FFI call. - - `ixePath` is a UTF-8 path to a memory-mappable `.ixe` env; - Rust loads it lazily. `ownedBlob` is a flat ByteArray of 32-byte - address blocks (one per owned const). -/ -def shardCheckIxVM (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (ownedBlob : ByteArray) - : Except String (Array G × IOBuffer × Array QueryCount) := - match shardCheckIxVM' toplevel funIdx ixePath ownedBlob with - | .error e => .error e - | .ok (output, (ioData, ioMap), queryCounts) => - let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ - let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ - let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } - .ok (output, ⟨ioData, ioMap⟩, queryCounts) - -/-- IxVM-native per-claim fast path for `Claim.check addr none`. - Builds the witness in Rust (closure rooted at `addrBytes`), - dispatches through `execute_ixvm`. `ixePath` is a UTF-8 path to - a memory-mappable `.ixe` env; `addrBytes` is the 32-byte target - address. Same shape as `shardCheckIxVM`. -/ -def checkAddrIxVM (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (ixePath : ByteArray) (addrBytes : ByteArray) +/-- Per-claim check against a Rust-owned `EnvHandle`. Reuses the + handle's already-parsed env across many calls. -/ +def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) : Except String (Array G × IOBuffer × Array QueryCount) := - match checkAddrIxVM' toplevel funIdx ixePath addrBytes with + match checkAddrWithEnv' toplevel funIdx envHandle addrBytes with | .error e => .error e | .ok (output, (ioData, ioMap), queryCounts) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ @@ -183,14 +190,11 @@ def checkAddrIxVM (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) -/-- Bytes-blob variant of `checkAddrIxVM`: the env is passed in as a - serialized blob (Lean's `Ixon.serEnv`) instead of a `.ixe` path. - Used by the compiled-Lean-env code path (`ix check NAME` without - `--ixe`), where the env is built in Lean memory. -/ -def checkEnvBytesIxVM (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envBytes : ByteArray) (addrBytes : ByteArray) +/-- Per-shard check against a Rust-owned `EnvHandle`. -/ +def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) : Except String (Array G × IOBuffer × Array QueryCount) := - match checkEnvBytesIxVM' toplevel funIdx envBytes addrBytes with + match shardCheckWithEnv' toplevel funIdx envHandle ownedBlob with | .error e => .error e | .ok (output, (ioData, ioMap), queryCounts) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 9e934759..adbc6340 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -102,39 +102,49 @@ def emitStats (compiled : Aiur.CompiledToplevel) try Aiur.printStats stats finally let _ ← IO.setStdout old -/-- Source for a `verify_claim` invocation. - - * `native`: env is a `.ixe` file; Rust mmaps it and builds the - witness in Rust (parallel closure walk + parallel byte→G). - * `nativeBytes`: env is in-memory (compiled-Lean-env path); - Lean serializes to bytes via `Ixon.serEnv`, Rust decodes via - `Env::get` and runs the same witness builder. Avoids the - tmp-file round trip. - * `lean`: a pre-built `ClaimWitness` — used by `--claim ` - over a non-`check addr none` persisted claim, and by - `--interp` mode. -/ -inductive WitnessSource where - | native (ixePath : String) (addr : Address) - | nativeBytes (envBytes : ByteArray) (addr : Address) - | lean (witness : IxVM.ClaimHarness.ClaimWitness) - -/-- Run a single check claim through the codegen'd IxVM Rust kernel - (`executeIxVM` or `checkAddrIxVM`). The bytecode interpreter is - no longer reachable from `ix check`. -/ +/-- What a single `runOne` invocation is targeting. + + * `addr`: full-closure `Claim.check addr none` — dispatch via + `checkAddrWithEnv` / `proveAddrWithEnv` (handle required). + * `shard`: `Claim.checkEnv root none` over `owned` blocks — + dispatch via `shardCheckWithEnv` / `shardProveWithEnv` + (handle required). + * `leanW`: a pre-built `ClaimWitness` — used by `--interp` + mode and by `--claim ` over a non-`check addr none` + persisted claim. No envHandle needed. + + The env lives once per CLI invocation in a Rust-owned + `Aiur.EnvHandle`. Lean threads a `@& EnvHandle` reference + through every per-target FFI call, eliminating per-call env + re-parse. -/ +inductive Target where + | addr (a : Address) + | shard (owned : Array Address) + | leanW (w : IxVM.ClaimHarness.ClaimWitness) + +/-- Run a single check claim through the codegen'd IxVM Rust kernel. + The `envHandle?` is `none` only for `.leanW` targets (`--interp` + fallback); the addr/shard arms require it. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (src : WitnessSource) - (label : String) : IO UInt32 := do + (statsOut : Option String) (envHandle? : Option Aiur.EnvHandle) + (target : Target) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" (← IO.getStdout).flush let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let buildBlob (owned : Array Address) : ByteArray := Id.run do + let mut blob := ByteArray.empty + for x in owned do blob := blob ++ x.hash + pure blob let res := - match src with - | .native ixePath addr => - compiled.bytecode.checkAddrIxVM funIdx ixePath.toUTF8 addr.hash - | .nativeBytes envBytes addr => - compiled.bytecode.checkEnvBytesIxVM funIdx envBytes addr.hash - | .lean witness => + match target, envHandle? with + | .addr a, some envHandle => + compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash + | .shard owned, some envHandle => + compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) + | .leanW witness, _ => compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + | _, none => + .error "internal: addr/shard target with no envHandle" match res with | .error e => IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" @@ -182,15 +192,23 @@ def runInterp (decls : Aiur.Source.Decls) def forEachClaim (ixePath : Option String) (claimHex : Option String) (names : List String) (keepGoing : Bool) (logTag : String) - (runOne : Ix.Claim → WitnessSource → String → IO UInt32) + (runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32) : IO UInt32 := do let mut failures : Array String := #[] match ixePath with | some path => + -- Build the env once for the entire batch. The lazy index parse + -- runs O(num_consts) once at handle construction; all per-name + -- FFI calls below share the parsed env (no per-call re-mmap). + let envHandle ← match Aiur.EnvHandle.fromIxe path with + | .error e => + IO.eprintln s!"EnvHandle.fromIxe {path}: {e}"; return 1 + | .ok h => pure h + -- We still load a Lean-side Ixon.Env for `resolveIxeAddr` (the + -- name → address resolution used by `--claim` / per-name modes) + -- and for the rare non-`check addr none` claim-variant Lean + -- witness builder. Anon load is lazy zero-copy. let bytes ← IO.FS.readBinFile path - -- Anon load: lazy zero-copy constants, binder metadata dropped. The Aiur - -- check circuit consumes only anonymous constants, blobs, and per-Defn - -- reducibility hints — mirrors the Rust kernel's `get_anon_mmap`. let ixonEnv ← match Ixon.deEnvAnon bytes with | .error e => IO.eprintln s!"Failed to deserialize {path}: {e}"; return 1 @@ -204,13 +222,13 @@ def forEachClaim -- `check addr none` shape has a Rust-witness fast path today. -- Other variants (eval/reveal/contains/checkEnv-with-asm) -- still build the witness in Lean. - let src : WitnessSource ← match claim with - | .check addr none => pure (.native path addr) + let target : Target ← match claim with + | .check addr none => pure (.addr addr) | _ => let witness ← IO.ofExcept <| IxVM.ClaimHarness.buildClaimWitness ixonEnv claim trees - pure (.lean witness) - if (← runOne claim src label) ≠ 0 then + pure (.leanW witness) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label else if names.isEmpty then let sorted := ixonEnv.named.toArray.qsort @@ -219,7 +237,7 @@ def forEachClaim let leanName := ixNameToLeanName ixName let label := toString leanName let claim := Ix.Claim.check named.addr none - if (← runOne claim (.native path named.addr) label) ≠ 0 then + if (← runOne claim (some envHandle) (.addr named.addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -232,31 +250,34 @@ def forEachClaim | some addr => let label := arg let claim := Ix.Claim.check addr none - if (← runOne claim (.native path addr) label) ≠ 0 then + if (← runOne claim (some envHandle) (.addr addr) label) ≠ 0 then failures := failures.push label if !keepGoing then break | none => if claimHex.isSome then IO.eprintln "error: --claim requires --ixe "; return 1 let env ← get_env! - -- Compiled-Lean-env path. Builds the Ixon env per-name in - -- Lean memory, serializes to a byte blob, and hands off to - -- the Rust witness builder via `nativeBytes`. Same fast path - -- as the `--ixe` route — only the env-source differs. - let buildOne (name : Lean.Name) : - IO (Ix.Claim × ByteArray × Address) := do + -- Compiled-Lean-env path. Builds a per-name Ixon env in Lean + -- memory, serializes to a byte blob, and constructs an + -- `EnvHandle` from it. Each name has its own closure-rooted + -- env, so the handle is rebuilt per name. (The `--ixe` arm + -- can share one handle across many names; this arm cannot + -- without a shared-env preprocess pass.) + let runOneByName (name : Lean.Name) (label : String) : IO UInt32 := do let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv name env let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name let claim := Ix.Claim.check addr none let envBytes := Ixon.serEnv ixonEnv - pure (claim, envBytes, addr) + let envHandle ← match Aiur.EnvHandle.fromBytes envBytes with + | .error e => throw (IO.userError s!"EnvHandle.fromBytes failed for {label}: {e}") + | .ok h => pure h + runOne claim (some envHandle) (.addr addr) label if names.isEmpty then let sorted := env.constants.toList.toArray.qsort (fun a b => toString a.1 < toString b.1) for (name, _) in sorted do let label := toString name - let (claim, envBytes, addr) ← buildOne name - if (← runOne claim (.nativeBytes envBytes addr) label) ≠ 0 then + if (← runOneByName name label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -269,8 +290,7 @@ def forEachClaim else continue | some name => let label := toString name - let (claim, envBytes, addr) ← buildOne name - if (← runOne claim (.nativeBytes envBytes addr) label) ≠ 0 then + if (← runOneByName name label) ≠ 0 then failures := failures.push label if !keepGoing then break @@ -383,11 +403,11 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) | .error e => IO.eprintln s!"shard witness build failed: {e}"; return 1 | .ok (claim, witness) => runOne claim witness s!"shard {shardK}" -/-- IxVM-native fast path: skip Lean-side `buildShardCheckEnvWitness` - and dispatch through the new `shardCheckIxVM` FFI which builds - the witness in Rust directly. `--ixe` path is required (the - Rust side memory-maps it). -/ -def runShardOwnedNative (ixePath : String) (compiled : Aiur.CompiledToplevel) +/-- IxVM-native fast path: dispatch through `shardCheckWithEnv` (a + Rust-owned `EnvHandle` reused across calls). Caller threads in + the pre-built envHandle so all shards in an all-shards run share + one env parse. -/ +def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) (printStats : Bool) (statsOut : Option String) (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do let owned := ownedConstsForBlocks ixonEnv blocks @@ -397,12 +417,10 @@ def runShardOwnedNative (ixePath : String) (compiled : Aiur.CompiledToplevel) IO.println s!"Typechecking {label}" (← IO.getStdout).flush let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let ixePathBytes := ixePath.toUTF8 - -- Flat 32-byte address ByteArray. let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash - match compiled.bytecode.shardCheckIxVM funIdx ixePathBytes blob with + match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob with | .error e => IO.eprintln s!"{label}: IxVM-native shard check error: {e}" return 1 @@ -419,8 +437,8 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 | some blocks => runShardOwned ixonEnv blocks shardK runOne -/-- IxVM-native shard check: skip Lean's `buildShardCheckEnvWitness` - by dispatching the witness build to Rust via `shardCheckIxVM`. -/ +/-- IxVM-native shard check, single shard. Builds an `EnvHandle` + once for this one call. -/ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) (statsOut : Option String) : IO UInt32 := do @@ -429,23 +447,30 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) | .ok (ixonEnv, shards) => match shards[shardK]? with | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 | some blocks => - runShardOwnedNative ixePath compiled printStats statsOut ixonEnv blocks shardK - -/-- IxVM-native check over EVERY shard. Caller-side: this skips the - coverage check; trust the user (or run a separate `--ixes`-only - coverage probe first). -/ + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + runShardOwnedNative envHandle compiled printStats statsOut ixonEnv blocks shardK + +/-- IxVM-native check over EVERY shard. Builds the `EnvHandle` ONCE + and shares it across every shard's FFI call (no per-shard + re-mmap). Caller-side: skips the coverage check; trust the user + (or run a separate `--ixes`-only coverage probe first). -/ def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) (statsOut : Option String) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h let maxJobs := max 1 (jobs?.getD shards.size) let mut rc : UInt32 := 0 for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do let tasks ← chunk.mapM fun (blocks, k) => IO.asTask (prio := .dedicated) - (runShardOwnedNative ixePath compiled printStats statsOut ixonEnv blocks k) + (runShardOwnedNative envHandle compiled printStats statsOut ixonEnv blocks k) for t in tasks do match t.get with | .ok r => if r != 0 then rc := 1 @@ -547,53 +572,41 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 | .ok t => pure t - -- The per-claim `runOne` accepts a `WitnessSource` (Rust-native - -- via `--ixe`, or Lean-built for the compiled-Lean-env path). - -- The legacy `--interp` route needs a fully-built `ClaimWitness` - -- in Lean, so it materialises the witness from the source first - -- (the `--interp` path is expected to be small constants for - -- developer ergonomics — heavy claims are run in production via - -- the codegen path). - let materialise (src : WitnessSource) : IO IxVM.ClaimHarness.ClaimWitness := - match src with - | .lean w => pure w - | .native ixe addr => do - let bytes ← IO.FS.readBinFile ixe - let ixonEnv ← match Ixon.deEnvAnon bytes with - | .error e => throw (IO.userError s!"deserialize {ixe} failed: {e}") - | .ok env => pure env - mkWitness addr ixonEnv - | .nativeBytes envBytes addr => do - let ixonEnv ← match Ixon.deEnv envBytes with - | .error e => throw (IO.userError s!"deserialize env bytes failed: {e}") - | .ok env => pure env - mkWitness addr ixonEnv - let runOne : Ix.Claim → WitnessSource → String → IO UInt32 ← + -- `runOne` consumes `(claim, envHandle?, target, label)`. For the + -- codegen path it dispatches via `runCompiled`. For `--interp` + -- it builds a `ClaimWitness` from the target — `.leanW` is + -- already a witness; `.addr` would require running the Rust + -- witness builder Lean-side, which `--interp` is meant to + -- bypass. So `--interp` rejects `.addr`/`.shard` targets here; + -- the legacy `runShardCheckManifest` path is used for `--interp` + -- shard mode. + let runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32 ← if interp then do let decls ← match toplevel.mkDecls with | .error e => IO.eprintln s!"mkDecls failed: {e}"; return 1 | .ok d => pure d - let go (_ : Ix.Claim) (src : WitnessSource) (label : String) : IO UInt32 := do - let witness ← materialise src - runInterp decls witness label + let go (_ : Ix.Claim) (_ : Option Aiur.EnvHandle) (target : Target) + (label : String) : IO UInt32 := + match target with + | .leanW w => runInterp decls w label + | _ => do + IO.eprintln s!"{label}: --interp requires a Lean witness; \ + addr/shard targets unreachable here" + pure 1 pure go else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - let go (_ : Ix.Claim) (src : WitnessSource) (label : String) : IO UInt32 := - runCompiled compiled printStats statsOut src label + let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target) + (label : String) : IO UInt32 := + runCompiled compiled printStats statsOut envHandle? target label pure go match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => - -- IxVM-native shard check: witness built in Rust (Lean's - -- `buildShardCheckEnvWitness` dominates per-shard wall time, - -- ~92%; native build avoids per-byte boxing into `Aiur.G`). - -- Falls back to the legacy path when `--interp` is set, since - -- the Lean interpreter consumes a `ClaimWitness` directly. if interp then return (← runShardCheckManifest manifest ixe k - (fun c w l => runOne c (.lean w) l)) + (fun c w l => runOne c none (.leanW w) l)) else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 @@ -602,7 +615,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | some ixe, some manifest, none => if interp then return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) - (fun c w l => runOne c (.lean w) l)) + (fun c w l => runOne c none (.leanW w) l)) else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index e0160036..e93d5fa9 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -61,7 +61,8 @@ private def friParameters : Aiur.FriParameters := { def proveOne (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) (claim : Ix.Claim) - (src : Ix.Cli.CheckCmd.WitnessSource) + (envHandle? : Option Aiur.EnvHandle) + (target : Ix.Cli.CheckCmd.Target) (label : String) : IO UInt32 := do IO.println s!"Proving {label}" (← IO.getStdout).flush @@ -71,31 +72,33 @@ def proveOne (aiurSystem : Aiur.AiurSystem) IO.eprintln s!"{label}: entrypoint `verify_claim` missing from compiled toplevel" return 1 let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - -- Native IxVM path: routes execution through the codegen'd Rust - -- kernel (`execute_generated`). For `Claim.check addr none` via - -- `--ixe`, witness + execute + STARK prove run end-to-end in - -- Rust (`proveAddrIxVM`) — no Lean-side per-byte boxing into - -- `Aiur.G`. The Lean fallback path consumes a pre-built - -- `ClaimWitness` (compiled-Lean-env, or a non-`check` persisted - -- claim). - let proof : Aiur.Proof ← match src with - | .native ixe addr => - match aiurSystem.proveAddrIxVM friParameters funIdx - ixe.toUTF8 addr.hash with + -- Native IxVM path: routes execution + STARK prove through the + -- codegen'd Rust kernel. `.addr` / `.shard` go through the + -- envHandle-based prove FFIs (witness + execute + prove all in + -- one Rust trip). `.leanW` consumes a pre-built `ClaimWitness` + -- via `proveIxVM` (used for non-`check addr none` `--claim hex`). + let proof : Aiur.Proof ← match target, envHandle? with + | .addr a, some envHandle => + match aiurSystem.proveAddrWithEnv friParameters funIdx envHandle a.hash with | .error e => - IO.eprintln s!"{label}: proveAddrIxVM error: {e}" + IO.eprintln s!"{label}: proveAddrWithEnv error: {e}" return 1 - | .ok (_aiurClaim, proof, _outIO) => pure proof - | .nativeBytes envBytes addr => - match aiurSystem.proveEnvBytesIxVM friParameters funIdx envBytes addr.hash with + | .ok (_claimBytes, proof, _outIO) => pure proof + | .shard owned, some envHandle => + let mut blob := ByteArray.empty + for x in owned do blob := blob ++ x.hash + match aiurSystem.shardProveWithEnv friParameters funIdx envHandle blob with | .error e => - IO.eprintln s!"{label}: proveEnvBytesIxVM error: {e}" + IO.eprintln s!"{label}: shardProveWithEnv error: {e}" return 1 - | .ok (_aiurClaim, proof, _outIO) => pure proof - | .lean witness => + | .ok (_claimBytes, proof, _outIO) => pure proof + | .leanW witness, _ => let (_aiurClaim, proof, _outIO) := aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer pure proof + | _, none => + IO.eprintln s!"{label}: internal: addr/shard target with no envHandle" + return 1 let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) @@ -105,42 +108,40 @@ def proveOne (aiurSystem : Aiur.AiurSystem) (`shardProveIxVM`): witness build, `execute_ixvm`, and STARK prove run in one FFI trip with the parallel Rust witness builder. -/ -def runShardProveNative (manifestPath ixePath : String) (shardK : Nat) +def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) + (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat) (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) - (printStats : Bool) : IO UInt32 := do - match (← Ix.Cli.CheckCmd.loadEnvAndShards manifestPath ixePath) with - | .error e => IO.eprintln e; return 1 - | .ok (ixonEnv, shards) => - match shards[shardK]? with - | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 - | some blocks => do - let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks - let mut blob := ByteArray.empty - for a in owned do - blob := blob ++ a.hash - let label := s!"shard {shardK}" - IO.println s!"Proving {label}" - (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - match aiurSystem.shardProveIxVM friParameters funIdx - ixePath.toUTF8 blob with + (_printStats : Bool) : IO UInt32 := do + match shards[shardK]? with + | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 + | some blocks => do + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + let label := s!"shard {shardK}" + IO.println s!"Proving {label}" + (← IO.getStdout).flush + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + match aiurSystem.shardProveWithEnv friParameters funIdx envHandle blob with + | .error e => + IO.eprintln s!"{label}: shardProveWithEnv error: {e}" + return 1 + | .ok (claimBytes, proof, _outIO) => + -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize + -- back to `Ix.Claim` to persist alongside the proof. Avoids + -- recomputing the closure walk + canonical AssumptionTree Lean-side. + match Ixon.runGet Ix.Claim.get claimBytes with | .error e => - IO.eprintln s!"{label}: shardProveIxVM error: {e}" + IO.eprintln s!"{label}: Claim wire-decode failed: {e}" return 1 - | .ok (_aiurClaim, proof, _outIO) => - -- Reconstruct the shard's CheckEnv claim from the owned - -- blocks so we can persist (claim, proof) like proveOne. - match IxVM.ClaimHarness.shardCheckEnvClaim ixonEnv owned with - | .error e => - IO.eprintln s!"{label}: claim reconstruct failed: {e}" - return 1 - | .ok (claim, _closure, _trees) => do - let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } - let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) - IO.println (toString proofAddr) - if printStats then pure () -- TODO: surface query-counts if needed - return 0 + | .ok claim => do + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } + let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + IO.println (toString proofAddr) + let _ := manifestPath -- kept for parity with previous signature + return 0 def runProveCmd (p : Cli.Parsed) : IO UInt32 := do Std.Internal.UV.System.osSetenv "IX_QUIET" "1" @@ -158,16 +159,28 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let runOne := proveOne aiurSystem compiled match ixePath, (p.flag? "ixes").map (·.as! String), (p.flag? "shard").map (·.as! Nat) with | some ixe, some manifest, some k => - -- IxVM-native shard prove: witness + execute + STARK prove all - -- in Rust via `shardProveIxVM`. - runShardProveNative manifest ixe k aiurSystem compiled false + -- IxVM-native shard prove. Build the envHandle once + share it + -- with the shard prove FFI. + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false | some ixe, some manifest, none => + -- IxVM-native all-shards prove. Same envHandle reused across + -- every shard. match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with | .error e => IO.eprintln e; return 1 - | .ok (_, shards) => + | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h let mut rc : UInt32 := 0 for k in [0 : shards.size] do - if (← runShardProveNative manifest ixe k aiurSystem compiled false) != 0 then + if (← runShardProveNative manifest envHandle ixonEnv shards k + aiurSystem compiled false) != 0 then rc := 1 pure rc | _, _, _ => diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 98a19507..2c52871e 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -31,6 +31,8 @@ static AIUR_PROOF_CLASS: LazyLock = LazyLock::new(ExternalClass::register_with_drop::); static AIUR_SYSTEM_CLASS: LazyLock = LazyLock::new(ExternalClass::register_with_drop::); +static IX_ENV_HANDLE_CLASS: LazyLock = + LazyLock::new(ExternalClass::register_with_drop::); // ============================================================================= // Lean FFI functions @@ -267,70 +269,58 @@ extern "C" fn rs_aiur_system_prove( result.into() } -/// `Bytecode.Toplevel.shardCheckIxVMFull`: end-to-end IxVM-native -/// shard check. -/// -/// Combines `buildShardCheckEnvWitness` (witness construction) and -/// `executeIxVM` into a single FFI call so the heavy IOBuffer never -/// crosses the Lean/Rust boundary. Builds the witness directly in -/// Rust from a memory-mapped `.ixe` env (no per-byte boxing into -/// Lean values), then dispatches to `execute_ixvm`. -/// -/// Returns the same `(output, ioBuffer, queryCounts)` triple as -/// `rs_aiur_toplevel_execute_ixvm` so the Lean shim can stay drop- -/// in compatible. + +// ============================================================================= +// EnvHandle constructors + with-env FFIs (PLAN.md "EnvHandle redesign") +// ============================================================================= + +/// `Aiur.EnvHandle.fromIxe`: open and parse a `.ixe` file once, +/// return an opaque Rust-owned handle. The mmap stays alive inside +/// the handle (via per-constant `Arc` windows) for as long as +/// Lean retains the `LeanExternal` reference. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_shard_check_ixvm( - toplevel: LeanAiurToplevel>, - fun_idx: LeanNat>, - ixe_path: LeanByteArray>, - owned_blob: LeanByteArray>, +extern "C" fn rs_aiur_env_handle_from_ixe( + path_bytes: LeanByteArray>, ) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let ixe_path_str = - String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); - - // Owned addresses arrive as a flat ByteArray of 32-byte blocks. - let bytes = owned_blob.as_bytes(); - if bytes.len() % 32 != 0 { - return LeanExcept::error_string(&format!( - "owned_blob: length {} not a multiple of 32", - bytes.len() - )); + let path_str = String::from_utf8_lossy(path_bytes.as_bytes()).into_owned(); + match ix::env_handle::EnvHandle::from_ixe_path(std::path::Path::new( + &path_str, + )) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_ixe: {e}")), } - let owned: Vec = bytes - .chunks_exact(32) - .map(|c| ix_common::address::Address::from_slice(c).unwrap()) - .collect(); - - // Load env via mmap (lazy, only touches what's read). - let env = match ixon::Env::get_anon_mmap( - std::path::Path::new(&ixe_path_str), - ) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), - }; - - // Build the witness in Rust (no per-byte Lean boxing). - let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_shard_check_env_witness( - &env, &owned, - ) { - Ok(t) => t, - Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), - }; +} - let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( - &toplevel, - fun_idx, - input, - &mut io_buffer, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), - }; +/// `Aiur.EnvHandle.fromBytes`: decode a serialized env blob +/// (`Ixon.serEnv` output) and harvest `anon_hints` post-decode. +/// Used by the compiled-Lean-env path (`ix check NAME` without +/// `--ixe`). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_env_handle_from_bytes( + bytes: LeanByteArray>, +) -> LeanExcept { + match ix::env_handle::EnvHandle::from_bytes(bytes.as_bytes()) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_bytes: {e}")), + } +} +/// Helper: summarise one execute's `QueryRecord` into a Lean +/// `Array (Nat × Nat)` of `(unique_rows, total_hits)` pairs, one per +/// function circuit followed by one per memory size. Mirrors the +/// summary code used by every check/prove FFI. +fn build_query_counts_array( + query_record: &aiur::execute::QueryRecord, + toplevel: &aiur::bytecode::Toplevel, +) -> LeanArray { let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( query_record.function_queries.len() + toplevel.memory_sizes.len(), ); @@ -354,300 +344,158 @@ extern "C" fn rs_aiur_toplevel_shard_check_ixvm( let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); query_counts.push(pair); } - let lean_query_counts = { - let arr = LeanArray::alloc(query_counts.len()); - for (i, &(rows, hits)) in query_counts.iter().enumerate() { - let pair = - LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); - arr.set(i, pair); - } - arr - }; + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr +} - let lean_io = build_lean_io_buffer(&io_buffer); - let io_counts = LeanProd::new(lean_io, lean_query_counts); - let result = LeanProd::new(build_g_array(&output), io_counts); - LeanExcept::ok(result) +/// Helper: decode a 32-byte address from a `LeanByteArray`. +fn decode_addr( + addr_bytes: &LeanByteArray>, +) -> Result { + let slice = addr_bytes.as_bytes(); + if slice.len() != 32 { + return Err(format!( + "addr_bytes: expected 32-byte address, got {} bytes", + slice.len() + )); + } + Ok( + ix_common::address::Address::from_slice(slice) + .expect("32-byte slice already length-checked"), + ) } -/// `Bytecode.Toplevel.checkAddrIxVM`: per-claim fast path for the -/// common `Claim.check addr none` variant. Builds the witness in -/// Rust from a memory-mapped `.ixe` env (closure rooted at `addr`), -/// then dispatches to `execute_ixvm`. Same `(output, ioBuffer, -/// queryCounts)` return shape as `rs_aiur_toplevel_shard_check_ixvm` -/// so the Lean shim is drop-in. -/// -/// Only handles `Claim.check addr none` — the asm-tree-bearing -/// variants of `Claim` still go through Lean witness for now (rare -/// path: only `ix check --claim ` loaded from store). +/// Helper: decode a flat 32-byte-block owned blob into `Vec
`. +fn decode_owned_blob( + owned_blob: &LeanByteArray>, +) -> Result, String> { + let bytes = owned_blob.as_bytes(); + if bytes.len() % 32 != 0 { + return Err(format!( + "owned_blob: length {} not a multiple of 32", + bytes.len() + )); + } + Ok( + bytes + .chunks_exact(32) + .map(|c| ix_common::address::Address::from_slice(c).unwrap()) + .collect(), + ) +} + +/// `Bytecode.Toplevel.checkAddrWithEnv`: per-claim check against a +/// Rust-owned `EnvHandle`. Builds the witness for +/// `Claim.check addr none` in Rust, runs `execute_ixvm`. Reuses the +/// handle's already-parsed env — no per-call mmap or anon_hints +/// harvest. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_check_addr_ixvm( +extern "C" fn rs_aiur_toplevel_check_addr_with_env( toplevel: LeanAiurToplevel>, fun_idx: LeanNat>, - ixe_path: LeanByteArray>, + env_handle: LeanExternal>, addr_bytes: LeanByteArray>, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let ixe_path_str = - String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); - - let addr_slice = addr_bytes.as_bytes(); - if addr_slice.len() != 32 { - return LeanExcept::error_string(&format!( - "addr_bytes: expected 32-byte address, got {} bytes", - addr_slice.len() - )); - } - let addr = ix_common::address::Address::from_slice(addr_slice) - .expect("32-byte slice already length-checked"); - - let env = match ixon::Env::get_anon_mmap( - std::path::Path::new(&ixe_path_str), - ) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + let addr = match decode_addr(&addr_bytes) { + Ok(a) => a, + Err(e) => return LeanExcept::error_string(&e), }; + let env = &env_handle.get().env; let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + match ix::aiur_ixvm_witness::build_claim_check_witness(env, &addr) { Ok(t) => t, Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( - &toplevel, - fun_idx, - input, - &mut io_buffer, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), - }; + let (query_record, output) = + match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, fun_idx, input, &mut io_buffer, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), + }; - let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( - query_record.function_queries.len() + toplevel.memory_sizes.len(), - ); - let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { - let mut rows = 0usize; - let mut hits = 0usize; - for (_, res) in q.iter() { - let m = usize::try_from(res.multiplicity.as_canonical_u64()) - .expect("multiplicity exceeds usize"); - if m != 0 { - rows += 1; - hits += m; - } - } - (rows, hits) - }; - for queries in &query_record.function_queries { - query_counts.push(summarize(queries)); - } - for size in &toplevel.memory_sizes { - let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); - query_counts.push(pair); - } - let lean_query_counts = { - let arr = LeanArray::alloc(query_counts.len()); - for (i, &(rows, hits)) in query_counts.iter().enumerate() { - let pair = - LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); - arr.set(i, pair); - } - arr - }; + let lean_query_counts = build_query_counts_array(&query_record, &toplevel); let lean_io = build_lean_io_buffer(&io_buffer); let io_counts = LeanProd::new(lean_io, lean_query_counts); let result = LeanProd::new(build_g_array(&output), io_counts); LeanExcept::ok(result) } -/// `Bytecode.Toplevel.checkAddrBytesIxVM`: same as -/// `rs_aiur_toplevel_check_addr_ixvm` but takes the env as a -/// serialized byte blob instead of a `.ixe` path. Used by the -/// compiled-Lean-env code path (`ix check NAME` without `--ixe`), -/// where the env is built in Lean memory and never written to disk. -/// Lean serializes with `Ixon.serEnv`; Rust decodes with `Env::get`. +/// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a +/// Rust-owned `EnvHandle`. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_toplevel_check_env_bytes_ixvm( +extern "C" fn rs_aiur_toplevel_shard_check_with_env( toplevel: LeanAiurToplevel>, fun_idx: LeanNat>, - env_bytes: LeanByteArray>, - addr_bytes: LeanByteArray>, + env_handle: LeanExternal>, + owned_blob: LeanByteArray>, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - - let addr_slice = addr_bytes.as_bytes(); - if addr_slice.len() != 32 { - return LeanExcept::error_string(&format!( - "addr_bytes: expected 32-byte address, got {} bytes", - addr_slice.len() - )); - } - let addr = ix_common::address::Address::from_slice(addr_slice) - .expect("32-byte slice already length-checked"); - - let mut cursor: &[u8] = env_bytes.as_bytes(); - let mut env = match ixon::Env::get(&mut cursor) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env decode: {e}")), + let owned = match decode_owned_blob(&owned_blob) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), }; - // `Env::get` doesn't harvest `anon_hints` from the named entries - // (only `get_anon` does). The kernel's `verify_claim` reads ch 3 - // (Defn reducibility hints) — populate it here so the witness - // includes hint entries for every `Defn` named entry. - let hints_to_insert: Vec<(ix_common::address::Address, ix_common::env::ReducibilityHints)> = - env.named.iter() - .filter_map(|entry| { - let named = entry.value(); - match &named.meta.info { - ixon::metadata::ConstantMetaInfo::Def { hints, .. } => - Some((named.addr.clone(), hints.clone())), - _ => None, - } - }) - .collect(); - for (addr, hints) in hints_to_insert { - env.anon_hints.insert(addr, hints); - } + let env = &env_handle.get().env; let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + match ix::aiur_ixvm_witness::build_shard_check_env_witness(env, &owned) { Ok(t) => t, Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (query_record, output) = match ix::aiur_ixvm_runner::execute_ixvm( - &toplevel, - fun_idx, - input, - &mut io_buffer, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), - }; + let (query_record, output) = + match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, fun_idx, input, &mut io_buffer, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), + }; - let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( - query_record.function_queries.len() + toplevel.memory_sizes.len(), - ); - let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { - let mut rows = 0usize; - let mut hits = 0usize; - for (_, res) in q.iter() { - let m = usize::try_from(res.multiplicity.as_canonical_u64()) - .expect("multiplicity exceeds usize"); - if m != 0 { - rows += 1; - hits += m; - } - } - (rows, hits) - }; - for queries in &query_record.function_queries { - query_counts.push(summarize(queries)); - } - for size in &toplevel.memory_sizes { - let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); - query_counts.push(pair); - } - let lean_query_counts = { - let arr = LeanArray::alloc(query_counts.len()); - for (i, &(rows, hits)) in query_counts.iter().enumerate() { - let pair = - LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); - arr.set(i, pair); - } - arr - }; + let lean_query_counts = build_query_counts_array(&query_record, &toplevel); let lean_io = build_lean_io_buffer(&io_buffer); let io_counts = LeanProd::new(lean_io, lean_query_counts); let result = LeanProd::new(build_g_array(&output), io_counts); LeanExcept::ok(result) } -/// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape -/// as `rs_aiur_system_prove`, but routes execution through the -/// codegen'd Rust kernel (`execute_generated`) via -/// `AiurSystem::prove_ixvm`. The resulting `Proof` is verification- -/// compatible with `rs_aiur_system_prove`. -#[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_ixvm( - aiur_system_obj: LeanExternal>, - fri_parameters: LeanAiurFriParameters>, - fun_idx: LeanNat>, - args: LeanArray>, - io_data_arr: LeanArray>, - io_map_arr: LeanArray>, -) -> LeanOwned { - let fri_parameters = decode_fri_parameters(&fri_parameters); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let args = args.map(|x| lean_unbox_g(&x)); - let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); - - let (claim, proof) = aiur_system_obj.get().prove_ixvm( - fri_parameters, - fun_idx, - &args, - &mut io_buffer, - ix::aiur_ixvm_runner::execute_ixvm, - ); - - let lean_proof: LeanOwned = - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); - let lean_io = build_lean_io_buffer(&io_buffer); - let proof_io_tuple = LeanProd::new(lean_proof, lean_io); - let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); - result.into() -} - -/// `AiurSystem.proveAddrIxVM`: end-to-end per-claim fast path — -/// builds the witness for `Claim.check addr none` in Rust, runs -/// `execute_ixvm`, then drives the STARK prove pipeline. Single -/// FFI trip; the `IOBuffer` never crosses the language boundary -/// before prove time. -/// -/// Returns `(claim_array, (proof, output_ioBuffer))` matching the -/// shape of `rs_aiur_system_prove_ixvm` so the Lean wrapper stays -/// drop-in. +/// `AiurSystem.proveAddrWithEnv`: per-claim prove against a +/// Rust-owned `EnvHandle`. Returns `(claim_bytes, proof, ioBuffer)` +/// — the claim's wire bytes are serialized via `ixon::Claim::put` +/// so Lean can deserialize directly into `Ix.Claim` without +/// reconstructing it from the target addr. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_addr_ixvm( +extern "C" fn rs_aiur_system_prove_addr_with_env( aiur_system_obj: LeanExternal>, fri_parameters: LeanAiurFriParameters>, fun_idx: LeanNat>, - ixe_path: LeanByteArray>, + env_handle: LeanExternal>, addr_bytes: LeanByteArray>, ) -> LeanExcept { let fri_parameters = decode_fri_parameters(&fri_parameters); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let ixe_path_str = - String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); - - let addr_slice = addr_bytes.as_bytes(); - if addr_slice.len() != 32 { - return LeanExcept::error_string(&format!( - "addr_bytes: expected 32-byte address, got {} bytes", - addr_slice.len() - )); - } - let addr = ix_common::address::Address::from_slice(addr_slice) - .expect("32-byte slice already length-checked"); - - let env = match ixon::Env::get_anon_mmap( - std::path::Path::new(&ixe_path_str), - ) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), + let addr = match decode_addr(&addr_bytes) { + Ok(a) => a, + Err(e) => return LeanExcept::error_string(&e), }; + let env = &env_handle.get().env; - let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + let (claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(env, &addr) { Ok(t) => t, Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (claim, proof) = aiur_system_obj.get().prove_ixvm( + let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm( fri_parameters, fun_idx, &input, @@ -655,69 +503,43 @@ extern "C" fn rs_aiur_system_prove_addr_ixvm( ix::aiur_ixvm_runner::execute_ixvm, ); + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let lean_claim_bytes = LeanByteArray::from_bytes(&claim_bytes); let lean_proof: LeanOwned = LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); let lean_io = build_lean_io_buffer(&io_buffer); - let proof_io_tuple = LeanProd::new(lean_proof, lean_io); - let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + let proof_io = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(lean_claim_bytes, proof_io); LeanExcept::ok(result) } -/// `AiurSystem.proveEnvBytesIxVM`: bytes-blob counterpart to -/// `rs_aiur_system_prove_addr_ixvm`. Used by `ix prove NAME` -/// without `--ixe` (compiled-Lean-env path). +/// `AiurSystem.shardProveWithEnv`: per-shard prove against a +/// Rust-owned `EnvHandle`. Same `(claim_bytes, proof, ioBuffer)` +/// return shape as `proveAddrWithEnv`. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_prove_env_bytes_ixvm( +extern "C" fn rs_aiur_system_shard_prove_with_env( aiur_system_obj: LeanExternal>, fri_parameters: LeanAiurFriParameters>, fun_idx: LeanNat>, - env_bytes: LeanByteArray>, - addr_bytes: LeanByteArray>, + env_handle: LeanExternal>, + owned_blob: LeanByteArray>, ) -> LeanExcept { let fri_parameters = decode_fri_parameters(&fri_parameters); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - - let addr_slice = addr_bytes.as_bytes(); - if addr_slice.len() != 32 { - return LeanExcept::error_string(&format!( - "addr_bytes: expected 32-byte address, got {} bytes", - addr_slice.len() - )); - } - let addr = ix_common::address::Address::from_slice(addr_slice) - .expect("32-byte slice already length-checked"); - - let mut cursor: &[u8] = env_bytes.as_bytes(); - let mut env = match ixon::Env::get(&mut cursor) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env decode: {e}")), + let owned = match decode_owned_blob(&owned_blob) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), }; - // `Env::get` doesn't harvest `anon_hints` from the named entries - // (only `get_anon` does). The kernel's `verify_claim` reads ch 3 - // (Defn reducibility hints) — populate it here so the witness - // includes hint entries for every `Defn` named entry. - let hints_to_insert: Vec<(ix_common::address::Address, ix_common::env::ReducibilityHints)> = - env.named.iter() - .filter_map(|entry| { - let named = entry.value(); - match &named.meta.info { - ixon::metadata::ConstantMetaInfo::Def { hints, .. } => - Some((named.addr.clone(), hints.clone())), - _ => None, - } - }) - .collect(); - for (addr, hints) in hints_to_insert { - env.anon_hints.insert(addr, hints); - } + let env = &env_handle.get().env; - let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_claim_check_witness(&env, &addr) { + let (claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_shard_check_env_witness(env, &owned) { Ok(t) => t, Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (claim, proof) = aiur_system_obj.get().prove_ixvm( + let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm( fri_parameters, fun_idx, &input, @@ -725,63 +547,42 @@ extern "C" fn rs_aiur_system_prove_env_bytes_ixvm( ix::aiur_ixvm_runner::execute_ixvm, ); + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let lean_claim_bytes = LeanByteArray::from_bytes(&claim_bytes); let lean_proof: LeanOwned = LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); let lean_io = build_lean_io_buffer(&io_buffer); - let proof_io_tuple = LeanProd::new(lean_proof, lean_io); - let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + let proof_io = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(lean_claim_bytes, proof_io); LeanExcept::ok(result) } -/// `AiurSystem.shardProveIxVM`: end-to-end per-shard fast path. -/// Same as `rs_aiur_system_prove_addr_ixvm` but the witness is a -/// `CheckEnv` over `owned_blob` (the shard's owned consts), built -/// via `build_shard_check_env_witness` (parallel closure walk + -/// per-byte conversion). + + +/// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape +/// as `rs_aiur_system_prove`, but routes execution through the +/// codegen'd Rust kernel (`execute_generated`) via +/// `AiurSystem::prove_ixvm`. The resulting `Proof` is verification- +/// compatible with `rs_aiur_system_prove`. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_system_shard_prove_ixvm( +extern "C" fn rs_aiur_system_prove_ixvm( aiur_system_obj: LeanExternal>, fri_parameters: LeanAiurFriParameters>, fun_idx: LeanNat>, - ixe_path: LeanByteArray>, - owned_blob: LeanByteArray>, -) -> LeanExcept { + args: LeanArray>, + io_data_arr: LeanArray>, + io_map_arr: LeanArray>, +) -> LeanOwned { let fri_parameters = decode_fri_parameters(&fri_parameters); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let ixe_path_str = - String::from_utf8_lossy(ixe_path.as_bytes()).into_owned(); - - let bytes = owned_blob.as_bytes(); - if bytes.len() % 32 != 0 { - return LeanExcept::error_string(&format!( - "owned_blob: length {} not a multiple of 32", - bytes.len() - )); - } - let owned: Vec = bytes - .chunks_exact(32) - .map(|c| ix_common::address::Address::from_slice(c).unwrap()) - .collect(); - - let env = match ixon::Env::get_anon_mmap( - std::path::Path::new(&ixe_path_str), - ) { - Ok(e) => e, - Err(e) => return LeanExcept::error_string(&format!("env load: {e}")), - }; - - let (_claim, input, mut io_buffer) = - match ix::aiur_ixvm_witness::build_shard_check_env_witness( - &env, &owned, - ) { - Ok(t) => t, - Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), - }; + let args = args.map(|x| lean_unbox_g(&x)); + let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); let (claim, proof) = aiur_system_obj.get().prove_ixvm( fri_parameters, fun_idx, - &input, + &args, &mut io_buffer, ix::aiur_ixvm_runner::execute_ixvm, ); @@ -791,9 +592,12 @@ extern "C" fn rs_aiur_system_shard_prove_ixvm( let lean_io = build_lean_io_buffer(&io_buffer); let proof_io_tuple = LeanProd::new(lean_proof, lean_io); let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); - LeanExcept::ok(result) + result.into() } + + + // ============================================================================= // Helpers // ============================================================================= diff --git a/crates/ix/src/env_handle.rs b/crates/ix/src/env_handle.rs new file mode 100644 index 00000000..551de795 --- /dev/null +++ b/crates/ix/src/env_handle.rs @@ -0,0 +1,59 @@ +//! `EnvHandle`: a Rust-owned `ixon::Env` exposed to Lean as an opaque +//! external handle. +//! +//! Built once per CLI invocation from either a memory-mappable `.ixe` +//! path or a `Ixon.serEnv`-shaped byte blob. All downstream per-claim / +//! per-shard FFI calls take a `&EnvHandle` (shared across the batch) so +//! the env is parsed exactly once instead of every call. +//! +//! `anon_hints` (`Defn` reducibility hints) are populated at handle +//! construction time. `Env::get_anon_mmap` already harvests them; +//! `Env::get` (full-form decode used by the bytes-blob path) does +//! not, so `from_bytes` runs the harvest post-decode. + +use ixon::{ + Env, + metadata::ConstantMetaInfo, +}; + +pub struct EnvHandle { + pub env: Env, +} + +impl EnvHandle { + /// Load via `Env::get_anon_mmap` (zero-copy mmap of the `.ixe` file). + /// Anon-mode parser already harvests `anon_hints` — no post-pass. + pub fn from_ixe_path(path: &std::path::Path) -> Result { + let env = Env::get_anon_mmap(path)?; + Ok(Self { env }) + } + + /// Decode a serialized env blob (`Ixon.serEnv` output) via + /// `Env::get`, then harvest `anon_hints` from each `Def` named + /// entry. Used by the compiled-Lean-env path where the env is built + /// in Lean memory and serialized for the cross-FFI handoff. + pub fn from_bytes(bytes: &[u8]) -> Result { + let mut cursor: &[u8] = bytes; + let mut env = Env::get(&mut cursor)?; + // `Env::get` reads named entries but doesn't populate + // `env.anon_hints`. Walk `env.named` and insert each `Def` + // variant's `hints`. Mirrors the in-line harvest inside + // `Env::get_anon`. + let hints: Vec<_> = env + .named + .iter() + .filter_map(|entry| { + let named = entry.value(); + if let ConstantMetaInfo::Def { hints, .. } = &named.meta.info { + Some((named.addr.clone(), hints.clone())) + } else { + None + } + }) + .collect(); + for (addr, h) in hints { + env.anon_hints.insert(addr, h); + } + Ok(Self { env }) + } +} diff --git a/crates/ix/src/lib.rs b/crates/ix/src/lib.rs index 7f7026f1..fb1b2aaa 100644 --- a/crates/ix/src/lib.rs +++ b/crates/ix/src/lib.rs @@ -5,3 +5,4 @@ pub mod aiur_ixvm; pub mod aiur_ixvm_runner; pub mod aiur_ixvm_witness; +pub mod env_handle; From 25fbc57cb55a7215d850ef1a647827aa06e08f60 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 15:21:12 -0700 Subject: [PATCH 10/11] ix codegen: add --check flag for CI; gate stale generated kernel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `ix codegen --check` compares the emitted Rust source against the on-disk `crates/ix/src/aiur_ixvm.rs` and exits 0 if identical, 1 otherwise. No write side effect. ~2 s warm; fast enough to gate on every PR. Wired into the `lean-test` CI job so a forgotten regen on a kernel-touching PR fails CI instead of merging stale generated code that drifts from the Bytecode → Rust emitter. --- .github/workflows/ci.yml | 2 ++ Ix/Cli/CodegenCmd.lean | 26 +++++++++++++++++++++++++- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 96d02bd3..9afa1a47 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,6 +22,8 @@ jobs: - uses: leanprover/lean-action@v1 with: build-args: "--wfail -v" + - name: Check codegen'd IxVM kernel is up to date + run: lake exe ix codegen --check - name: Test Ix CLI run: lake test -- cli - name: Aiur tests diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index 4fbdef59..e2417122 100644 --- a/Ix/Cli/CodegenCmd.lean +++ b/Ix/Cli/CodegenCmd.lean @@ -35,7 +35,8 @@ open Aiur /-- Fixed destination — compile-time constant, no CLI override. -/ def codegenOutPath : String := "crates/ix/src/aiur_ixvm.rs" -def runCodegenCmd (_p : Cli.Parsed) : IO UInt32 := do +def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do + let checkOnly := p.hasFlag "check" -- Compile the IxVM source to bytecode. let src ← match IxVM.ixVM with | .ok src => pure src @@ -44,6 +45,26 @@ def runCodegenCmd (_p : Cli.Parsed) : IO UInt32 := do | .ok c => pure c | .error e => IO.eprintln s!"Aiur compile error: {e}"; return 1 let rustSource := Aiur.Codegen.emit compiled.bytecode + if checkOnly then + -- CI mode: compare emitted source against the on-disk file. + -- Exit 0 if identical, 1 otherwise. Does not write. + let existing ← try + pure (some (← IO.FS.readFile codegenOutPath)) + catch _ => pure none + match existing with + | none => + IO.eprintln s!"[codegen --check] {codegenOutPath} missing" + return 1 + | some onDisk => + if onDisk == rustSource then + IO.println s!"[codegen --check] {codegenOutPath} up to date \ + ({rustSource.length} bytes, {compiled.bytecode.functions.size} aiur fns)" + return 0 + else + IO.eprintln s!"[codegen --check] {codegenOutPath} STALE: \ + on-disk {onDisk.length} bytes, would emit {rustSource.length} bytes. \ + Re-run `ix codegen` and commit the result." + return 1 IO.FS.writeFile codegenOutPath rustSource IO.println s!"[codegen] wrote {rustSource.length} bytes to {codegenOutPath} \ ({compiled.bytecode.functions.size} aiur fns)" @@ -55,6 +76,9 @@ open Ix.Cli.CodegenCmd in def codegenCmd : Cli.Cmd := `[Cli| "codegen" VIA runCodegenCmd; "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ix/src/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces." + + FLAGS: + "check"; "CI mode: compare the emitted source against the on-disk file at `crates/ix/src/aiur_ixvm.rs` and exit 0 if identical, 1 otherwise. Does not modify the file." ] end From b6c76a4056c070267ce19ca4a22ea70154cbc71c Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 30 Jun 2026 17:07:48 -0700 Subject: [PATCH 11/11] ix check: --interp {source|bytecode} to bypass codegen kernel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two interpreter modes behind a single `--interp` flag: * `--interp source`: Aiur source interpreter (`Aiur.runFunction` over the source-level `Decls`). Richer per-step error diagnostics. * `--interp bytecode`: generic Aiur bytecode interpreter (`Bytecode.Toplevel.execute`, `rs_aiur_toplevel_execute` route). Skips the `ix codegen` + `cargo build --release` cycle needed after editing `Ix/IxVM/*.lean` — the bytecode is rebuilt Lean-side at exe load. Slower per-check than the codegen kernel; ideal for tight iteration on the IxVM source. * omit the flag entirely for the native codegen kernel (default). Invalid values (e.g. `--interp foo`) fail fast with a clear error. # Plumbing The `check_addr_with_env` and `shard_check_with_env` FFIs take a `use_bytecode: bool` and dispatch via a shared `dispatch_execute` helper. `--interp bytecode` sets it to `true`. The `.leanW` arm of `runCompiled` also picks between `Bytecode.Toplevel.execute` and `executeIxVM` based on the same flag. The `--interp source` path requires a Lean `ClaimWitness`. The existing driver had switched to `.addr`/`.shard` targets against the Rust-owned `EnvHandle`; source-interp had no way to materialise those. `forEachClaim` now takes a `forceLeanWitness : Bool` — when true, it builds a Lean witness for every target (via `mkWitness` / `loadIxonEnv` for the compiled-Lean-env path) and passes `.leanW` so `runInterp` can consume it directly. # Sanity * `ix check Std.Time.Week.Offset.ofMilliseconds` (warm): 9.3 s wall, FFT = 12_430_516_949 (codegen kernel). * `ix check --interp bytecode Std.Time.Week.Offset.ofMilliseconds` (warm): 14.6 s wall, FFT = 12_430_516_949 (bytecode interp). * `ix check --interp source Eq` (warm): 6.3 s wall, output `Eq: ()`. * `ix check --interp garbage Nat.add_comm`: exits 1 with clear error. --- Ix/Aiur/Semantics/BytecodeFfi.lean | 25 ++++++---- Ix/Cli/CheckCmd.lean | 79 ++++++++++++++++++++---------- Ix/Cli/ProveCmd.lean | 2 +- crates/ffi/src/aiur/protocol.rs | 63 +++++++++++++++++------- 4 files changed, 113 insertions(+), 56 deletions(-) diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index b2362c8f..420be269 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -164,25 +164,30 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel) @[extern "rs_aiur_toplevel_check_addr_with_env"] private opaque checkAddrWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → Except String (Array G × (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × Array (Nat × Nat)) @[extern "rs_aiur_toplevel_shard_check_with_env"] private opaque shardCheckWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → Except String (Array G × (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × Array (Nat × Nat)) -/-- Per-claim check against a Rust-owned `EnvHandle`. Reuses the - handle's already-parsed env across many calls. -/ +/-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode` + selects the generic Aiur bytecode interpreter + (`Bytecode.Toplevel.execute`) over the codegen'd IxVM kernel + (`execute_ixvm`); useful for tight iteration loops on Lean-side + IxVM source where regenerating `crates/ix/src/aiur_ixvm.rs` and + recompiling Rust is too slow. -/ def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (addrBytes : ByteArray) (useBytecode : Bool := false) : Except String (Array G × IOBuffer × Array QueryCount) := - match checkAddrWithEnv' toplevel funIdx envHandle addrBytes with + match checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode with | .error e => .error e | .ok (output, (ioData, ioMap), queryCounts) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ @@ -190,11 +195,13 @@ def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) -/-- Per-shard check against a Rust-owned `EnvHandle`. -/ +/-- Per-shard check against a Rust-owned `EnvHandle`. See + `checkAddrWithEnv` for `useBytecode` semantics. -/ def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (ownedBlob : ByteArray) (useBytecode : Bool := false) : Except String (Array G × IOBuffer × Array QueryCount) := - match shardCheckWithEnv' toplevel funIdx envHandle ownedBlob with + match shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode with | .error e => .error e | .ok (output, (ioData, ioMap), queryCounts) => let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index adbc6340..067436a2 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -126,7 +126,8 @@ inductive Target where The `envHandle?` is `none` only for `.leanW` targets (`--interp` fallback); the addr/shard arms require it. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (envHandle? : Option Aiur.EnvHandle) + (statsOut : Option String) (useBytecode : Bool) + (envHandle? : Option Aiur.EnvHandle) (target : Target) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" (← IO.getStdout).flush @@ -138,11 +139,14 @@ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) let res := match target, envHandle? with | .addr a, some envHandle => - compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash + compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash useBytecode | .shard owned, some envHandle => - compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) + compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) useBytecode | .leanW witness, _ => - compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + if useBytecode then + compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer + else + compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer | _, none => .error "internal: addr/shard target with no envHandle" match res with @@ -191,7 +195,7 @@ def runInterp (decls : Aiur.Source.Decls) variant isn't `check addr none`. -/ def forEachClaim (ixePath : Option String) (claimHex : Option String) (names : List String) - (keepGoing : Bool) (logTag : String) + (keepGoing : Bool) (logTag : String) (forceLeanWitness : Bool) (runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32) : IO UInt32 := do let mut failures : Array String := #[] @@ -237,7 +241,12 @@ def forEachClaim let leanName := ixNameToLeanName ixName let label := toString leanName let claim := Ix.Claim.check named.addr none - if (← runOne claim (some envHandle) (.addr named.addr) label) ≠ 0 then + let target : Target ← + if forceLeanWitness then + let w ← mkWitness named.addr ixonEnv + pure (.leanW w) + else pure (.addr named.addr) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -250,7 +259,12 @@ def forEachClaim | some addr => let label := arg let claim := Ix.Claim.check addr none - if (← runOne claim (some envHandle) (.addr addr) label) ≠ 0 then + let target : Target ← + if forceLeanWitness then + let w ← mkWitness addr ixonEnv + pure (.leanW w) + else pure (.addr addr) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label if !keepGoing then break | none => @@ -267,11 +281,15 @@ def forEachClaim let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv name env let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name let claim := Ix.Claim.check addr none - let envBytes := Ixon.serEnv ixonEnv - let envHandle ← match Aiur.EnvHandle.fromBytes envBytes with - | .error e => throw (IO.userError s!"EnvHandle.fromBytes failed for {label}: {e}") - | .ok h => pure h - runOne claim (some envHandle) (.addr addr) label + if forceLeanWitness then + let w ← mkWitness addr ixonEnv + runOne claim none (.leanW w) label + else + let envBytes := Ixon.serEnv ixonEnv + let envHandle ← match Aiur.EnvHandle.fromBytes envBytes with + | .error e => throw (IO.userError s!"EnvHandle.fromBytes failed for {label}: {e}") + | .ok h => pure h + runOne claim (some envHandle) (.addr addr) label if names.isEmpty then let sorted := env.constants.toList.toArray.qsort (fun a b => toString a.1 < toString b.1) @@ -408,7 +426,7 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) the pre-built envHandle so all shards in an all-shards run share one env parse. -/ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) - (printStats : Bool) (statsOut : Option String) + (printStats : Bool) (statsOut : Option String) (useBytecode : Bool) (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do let owned := ownedConstsForBlocks ixonEnv blocks IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ @@ -420,7 +438,7 @@ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledTo let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash - match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob with + match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob useBytecode with | .error e => IO.eprintln s!"{label}: IxVM-native shard check error: {e}" return 1 @@ -441,7 +459,7 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) once for this one call. -/ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) : IO UInt32 := do + (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => match shards[shardK]? with @@ -450,7 +468,7 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 | .ok h => pure h - runShardOwnedNative envHandle compiled printStats statsOut ixonEnv blocks shardK + runShardOwnedNative envHandle compiled printStats statsOut useBytecode ixonEnv blocks shardK /-- IxVM-native check over EVERY shard. Builds the `EnvHandle` ONCE and shares it across every shard's FFI call (no per-shard @@ -458,7 +476,7 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) (or run a separate `--ixes`-only coverage probe first). -/ def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) : IO UInt32 := do + (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => @@ -470,7 +488,7 @@ def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Na for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do let tasks ← chunk.mapM fun (blocks, k) => IO.asTask (prio := .dedicated) - (runShardOwnedNative envHandle compiled printStats statsOut ixonEnv blocks k) + (runShardOwnedNative envHandle compiled printStats statsOut useBytecode ixonEnv blocks k) for t in tasks do match t.get with | .ok r => if r != 0 then rc := 1 @@ -555,7 +573,14 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do -- Always silence the Rust-side `[compile_env]` progress logs. The -- per-name labels + stats are signal enough at this layer. Std.Internal.UV.System.osSetenv "IX_QUIET" "1" - let interp := p.hasFlag "interp" + let interpMode : Option String := (p.flag? "interp").map (·.as! String) + let interpSource := interpMode == some "source" + let useBytecode := interpMode == some "bytecode" + match interpMode with + | none | some "source" | some "bytecode" => pure () + | some other => + IO.eprintln s!"error: --interp expects \"source\" or \"bytecode\", got \"{other}\"" + return 1 let keepGoing := p.hasFlag "keep-going" let statsOut : Option String := (p.flag? "stats-out").map (·.as! String) @@ -581,7 +606,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do -- the legacy `runShardCheckManifest` path is used for `--interp` -- shard mode. let runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32 ← - if interp then do + if interpSource then do let decls ← match toplevel.mkDecls with | .error e => IO.eprintln s!"mkDecls failed: {e}"; return 1 | .ok d => pure d @@ -600,20 +625,20 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | .ok c => pure c let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target) (label : String) : IO UInt32 := - runCompiled compiled printStats statsOut envHandle? target label + runCompiled compiled printStats statsOut useBytecode envHandle? target label pure go match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => - if interp then + if interpSource then return (← runShardCheckManifest manifest ixe k (fun c w l => runOne c none (.leanW w) l)) else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut) + return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode) | some ixe, some manifest, none => - if interp then + if interpSource then return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) (fun c w l => runOne c none (.leanW w) l)) else do @@ -621,9 +646,9 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c return (← runShardManifestAllNative manifest ixe - ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut) + ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut useBytecode) | _, _, _ => - forEachClaim ixePath claimHex names keepGoing "check" runOne + forEachClaim ixePath claimHex names keepGoing "check" interpSource runOne end Ix.Cli.CheckCmd @@ -633,7 +658,7 @@ def checkCmd : Cli.Cmd := `[Cli| "Typecheck Lean / `.ixe` constants through the IxVM Aiur kernel" FLAGS: - interp; "Use the Aiur interpreter (richer per-execution error diagnostics) instead of the codegen'd IxVM Rust kernel." + interp : String; "Use an interpreter instead of the codegen'd IxVM Rust kernel. Modes: `source` = Aiur source interpreter (richer per-execution error diagnostics, slowest); `bytecode` = generic Aiur bytecode interpreter (skips the regen + cargo rebuild cycle when iterating on `Ix/IxVM/*.lean`). Omit the flag entirely for the native codegen kernel." "keep-going"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index e93d5fa9..8f515882 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -184,7 +184,7 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do rc := 1 pure rc | _, _, _ => - Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" runOne + Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne end Ix.Cli.ProveCmd diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 2c52871e..c46bba0e 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -389,17 +389,42 @@ fn decode_owned_blob( ) } +/// Run `fun_idx` with `input` + `io_buffer`, routing through either +/// the codegen'd IxVM kernel (`use_bytecode = false`) or the +/// generic Aiur bytecode interpreter (`use_bytecode = true`). +/// The bytecode interpreter doesn't require regenerating the +/// codegen'd Rust kernel after Lean-side IxVM source changes — +/// useful for tight iteration loops on `Ix/IxVM/*.lean`. +#[inline] +fn dispatch_execute( + toplevel: &aiur::bytecode::Toplevel, + fun_idx: aiur::bytecode::FunIdx, + input: Vec, + io_buffer: &mut aiur::execute::IOBuffer, + use_bytecode: bool, +) -> Result<(aiur::execute::QueryRecord, Vec), String> { + if use_bytecode { + toplevel + .execute(fun_idx, input, io_buffer) + .map_err(|e| format!("execute (bytecode): {e}")) + } else { + ix::aiur_ixvm_runner::execute_ixvm(toplevel, fun_idx, input, io_buffer) + .map_err(|e| format!("execute_ixvm: {e}")) + } +} + /// `Bytecode.Toplevel.checkAddrWithEnv`: per-claim check against a -/// Rust-owned `EnvHandle`. Builds the witness for -/// `Claim.check addr none` in Rust, runs `execute_ixvm`. Reuses the -/// handle's already-parsed env — no per-call mmap or anon_hints -/// harvest. +/// Rust-owned `EnvHandle`. `use_bytecode` selects the executor: +/// `false` = codegen'd IxVM kernel (`execute_ixvm`), +/// `true` = generic Aiur bytecode interpreter +/// (`Toplevel::execute`). #[unsafe(no_mangle)] extern "C" fn rs_aiur_toplevel_check_addr_with_env( toplevel: LeanAiurToplevel>, fun_idx: LeanNat>, env_handle: LeanExternal>, addr_bytes: LeanByteArray>, + use_bytecode: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -415,13 +440,12 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (query_record, output) = - match ix::aiur_ixvm_runner::execute_ixvm( - &toplevel, fun_idx, input, &mut io_buffer, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), - }; + let (query_record, output) = match dispatch_execute( + &toplevel, fun_idx, input, &mut io_buffer, use_bytecode, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&e), + }; let lean_query_counts = build_query_counts_array(&query_record, &toplevel); let lean_io = build_lean_io_buffer(&io_buffer); @@ -431,13 +455,15 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( } /// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a -/// Rust-owned `EnvHandle`. +/// Rust-owned `EnvHandle`. See `checkAddrWithEnv` for `use_bytecode` +/// semantics. #[unsafe(no_mangle)] extern "C" fn rs_aiur_toplevel_shard_check_with_env( toplevel: LeanAiurToplevel>, fun_idx: LeanNat>, env_handle: LeanExternal>, owned_blob: LeanByteArray>, + use_bytecode: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -453,13 +479,12 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env( Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), }; - let (query_record, output) = - match ix::aiur_ixvm_runner::execute_ixvm( - &toplevel, fun_idx, input, &mut io_buffer, - ) { - Ok(p) => p, - Err(e) => return LeanExcept::error_string(&format!("execute_ixvm: {e}")), - }; + let (query_record, output) = match dispatch_execute( + &toplevel, fun_idx, input, &mut io_buffer, use_bytecode, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&e), + }; let lean_query_counts = build_query_counts_array(&query_record, &toplevel); let lean_io = build_lean_io_buffer(&io_buffer);